mirage 0.1.2

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create default@mirage

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    mirage (0.1.1)
+      mechanize (>= 1.0.0)
+      rack (~> 1.1.0)
+      ramaze (>= 2011.01.30)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    cucumber (0.10.2)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (>= 2.3.5)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.3.5)
+      json (>= 1.4.6)
+    innate (2011.01)
+      rack (>= 1.1.0)
+    json (1.5.1)
+    mechanize (1.0.0)
+      nokogiri (>= 1.2.1)
+    nokogiri (1.4.4)
+    rack (1.1.2)
+    rake (0.8.7)
+    ramaze (2011.01.30)
+      innate (>= 2010.03)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    term-ansicolor (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  cucumber
+  mirage!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,93 @@
+Mirage
+======
+Mirage is an application for hosting responses to fool your applications into thinking that they are talking to real endpoints whilst you are developing them. 
+Its accessible via HTTP has a RESful interface so is easy to interact with.  
+
+Below are a few instructions telling you how to use Mirage. They are definately enough to get you up and running, but if you want to know everything you 
+can do then have a look at the feature files for a complete low down. I know I know, it sounds a bit corney to say that a project's documentation is its tests. But they are written using
+cucumber and a lot of effort has been put in to try and make these things readable... promise!  
+
+Any ideas/improvements or feedback you have are greatly appreciated.
+
+I hope that its useful. 
+
+Leon
+
+P.s. Currently Mirage only runs on Linux; Rubies 1.8, 1.9 and JRuby. I plan to add support for Windows and MacOsX very soon.
+
+Installation & Running
+----------------------
+
+`gem install mirage`  
+`mirage start`  
+    
+That's it, its running, your done... No seriously, go to http://localhost:7001/mirage and you see that its running.
+
+There are also a [few options](https://github.com/Ladtech/sandbox/blob/master/mirage/features/setting_responses_with_a_delay.feature) that let you configure things like what port mirage is started on.
+
+Usage:
+------
+The examples below assume that you are running mirage with the default settings.
+
+###Set
+Example:
+    http://localhost:7001/mirage/set/my_endpoint?response=hello  
+
+By hitting this url, you have just put a response on mirage. Your endpoint, the bit after 'http://localhost:7001/mirage/set', can be anything you like for example 'anything/you/like'. In return for
+  doing this Mirage will return you a response id. You can use this id to various things with this response.
+
+###Get
+How do I get my response back back?
+
+Example:
+    http://localhost:7001/mirage/get/my_endpoint  
+  
+All you need to do is 'get/the/endpoint' and Mirage will serve which ever response has been set.  
+
+When it comes to getting and setting responses, Mirage lets you do quite a lot:
+  
+ * [Setting responses](https://github.com/lashd/Mirage/blob/master/features/setting_responses.feature) - The basics
+
+ * [Associate responses on an endpoint with a pattern](https://github.com/lashd/Mirage/blob/master/features/setting_responses_with_pattern_matching.feature) - This lets you simulate different behaviour depending on the request that is sent to Mirage
+ 
+ * [Introduce a delay](https://github.com/Ladtech/sandbox/blob/master/mirage/features/setting_responses_with_a_delay.feature) - Make things a bit more realistic and make your application wait.
+   
+ * [Templatise responses](https://github.com/lashd/Mirage/blob/master/features/response_templates.feature) - Substitute values found in a request back in to the response.
+  
+ * [File hosting](https://github.com/lashd/Mirage/blob/master/features/file_hosting.feature) - As well as text based responses, Mirage can also host files
+ 
+ * [Root responses](https://github.com/lashd/Mirage/blob/master/features/root_responses.feature) - Want default a response for all urls under an endpoint? this is how.
+ 
+ * [Default responses](https://github.com/lashd/Mirage/blob/master/features/default_responses.feature) - Prime on or after startup with a bunch of default responses  
+     
+ 
+###Check
+If you want to see what data was sent when a response is triggered you can use the response's unique id to get that data back. This can be useful as it lets you test that your application is sending the right data.
+Example:
+    http://localhost:7001/mirage/check/response_id
+
+###Peek  
+If you want to see a what a response is set as then you can [peek](https://github.com/lashd/Mirage/blob/master/features/peeking_at_response.feature) at it using the unique id you got when setting the response.
+Peeking at response will return allow you to see what a response is set to without causing a request to be tracked.
+
+Example:
+    http://localhost:7001/mirage/peek/your_response_id
+###Snapshot and Rollback
+Once you have set up Mirage just as you want it, you can snapshot its state. This lets you roll it back to that state when ever you want to.
+
+Example:
+    http://localhost:7001/mirage/snapshot
+    http://localhost:7001/mirage/rollback  
+
+###Ruby Client
+You can use whatever you like interact with Mirage but if you are using Ruby and you and have other things to do, then you can use 
+the client that you get when you install Mirage.
+  
+Example:
+    require 'rubygems
+    require 'mirage'
+    Mirage::Client.new.set('greeting', :response=>'hello')` 
+
+Your response is now waiting for you at: http://localhost:7001/mirage/get/greeting :)
+The client has methods that let allow you to fully interact with mirage. [So go ahead and check it out](https://github.com/lashd/Mirage/tree/master/features/client).  
+

data/bin/mirage

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")
+require 'mirage'
+include Mirage::Util
+RUBY_CMD = RUBY_PLATFORM == 'JAVA' ? 'jruby' : 'ruby'
+
+
+def start_mirage(args, mirage)
+  puts "Starting Mirage"
+  system "(#{RUBY_CMD} #{File.dirname(__FILE__)}/../lib/start_mirage.rb #{args.join(' ')}) > /dev/null 2>&1 &"
+  wait_until do
+    mirage.running?
+  end
+end
+
+def mirage_process_ids
+  mirage_cmdline_files = Dir['/proc/*/cmdline'].find_all { |cmdline_file| File.read(cmdline_file) =~ /Mirage Server|start_mirage/ }
+  mirage_cmdline_files.collect{|mirage_cmdline_file| File.read("#{File.dirname(mirage_cmdline_file)}/stat").split(' ').first.to_i }
+end
+
+if ARGV.include?('start')
+
+  options =  parse_options(ARGV)
+  mirage_client = Mirage::Client.new "http://localhost:#{options[:port]}/mirage"
+
+  if mirage_client.running?
+    puts "Mirage already running"
+    exit 1
+  end
+
+  start_mirage(ARGV, mirage_client)
+  begin
+    mirage_client.load_defaults
+  rescue Mirage::InternalServerException => e
+    puts "WARN: #{e.message}"
+  end
+
+
+elsif ARGV.include?('stop')
+  puts "Stoping Mirage"
+  begin
+    mirage_process_ids.each do |id|
+      puts "killing #{id}"
+      Process.kill(9, id)
+    end
+
+  rescue
+    puts 'Mirage is not running'
+  end
+else
+  parse_options ['--help']
+  exit 1
+end

data/features/checking_for_requests.feature

@@ -0,0 +1,74 @@
+Feature: After a response has been served from Mirage, the content of the request that triggered it can be retrieved. This is useful
+  for testing that the correct information was sent to the endpint that the MockServer is stubbing,
+
+  On setting a response, a unique id is returned which can be used to look up the last request made to get that response.
+
+  If the the response is reset then the same id is returned in order to make it easier to keep track of.
+
+  Responses hosted on the same endpoint but with a pattern are considered unique and so get their own ID.
+
+  If the request body contains content this is stored. Otherwise it is the query string that is stored.
+  
+  If a response is 'peeked' this does not count as a request that should be stored.
+
+  Background: There is a response already on Mirage
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+
+  Scenario: Querying a response that was triggered by a request that had content in the body
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Hello MockServer
+    """
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then 'Hello MockServer' should be returned
+
+
+  Scenario: Querying a response that was triggered by a request with a query string
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | surname   | Davis |
+      | firstname | Leon  |
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then 'surname=Davis&firstname=Leon' should be returned
+
+
+  Scenario: Querying a response that has not been served yet
+    Given I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+
+  Scenario: A response is peeked at
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Hello
+    """
+    And I hit 'http://localhost:7001/mirage/peek/1'
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then 'Hello' should be returned
+
+
+  Scenario: A default response and one for the same endpoint with a pattern are set
+    When I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello who ever you are |
+    Then '1' should be returned
+
+    When I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon |
+      | pattern  | Leon       |
+    Then '3' should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    My name is Joel
+    """
+    And I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    My name is Leon
+    """
+    And I hit 'http://localhost:7001/mirage/check/1'
+    Then 'My name is Joel' should be returned
+    And I hit 'http://localhost:7001/mirage/check/3'
+    Then 'My name is Leon' should be returned
+
+

data/features/clearing_requests_and_responses.feature

@@ -0,0 +1,81 @@
+Feature: Responses and requests can be cleared.
+  Clearing a response clears any associated request information that may have been stored.
+
+  Usage:
+  ${mirage_url}/clear - Clear all responses and requests
+  ${mirage_url}/clear/requests - Clear all requests
+  ${mirage_url}/clear/response_id - Clear a requests and response for a particular response
+  ${mirage_url}/clear/request/response_id - Clear request for a particular response
+
+
+
+  Background: The MockServer has already got a response for greeting and leaving on it.
+    Given I post to 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+    And I post to 'http://localhost:7001/mirage/set/leaving' with parameters:
+      | response | Goodbye |
+
+
+
+  Scenario: Clearing all responses
+    Given I hit 'http://localhost:7001/mirage/clear'
+
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/leaving'
+    Then a 404 should be returned
+
+
+  Scenario: Clearing a particular response
+    Given I hit 'http://localhost:7001/mirage/clear/1'
+
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/leaving'
+    Then 'Goodbye' should be returned
+
+
+  Scenario: Clearing all requests
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Say 'Hello' to me
+    """
+    And I hit 'http://localhost:7001/mirage/get/leaving' with request body:
+    """
+    Say 'Goodbye' to me
+    """
+    And I hit 'http://localhost:7001/mirage/clear'
+
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/check/2'
+    Then a 404 should be returned
+
+
+  Scenario: Clearing a stored request request for a prticular response
+    Given I hit 'http://localhost:7001/mirage/get/leaving' with request body:
+    """
+    See you later
+    """
+
+    When I hit 'http://localhost:7001/mirage/clear/request/2'
+    Then I hit 'http://localhost:7001/mirage/check/2'
+    And a 404 should be returned
+
+
+    Scenario: Querying a response that has been cleared
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    greet me :)
+    """
+    And I hit 'http://localhost:7001/mirage/clear/1'
+
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned

data/features/client/checking_for_requests.feature

@@ -0,0 +1,20 @@
+Feature: Requests made to the Mirage Server can be tracked using the Mirage client
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+
+  Scenario: The MockServer returns a response
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | name | leon  |
+    Then I run
+    """
+       Mirage::Client.new.check(1).should == 'name=leon'
+    """

data/features/client/clearing_responses.feature

@@ -0,0 +1,75 @@
+Feature: The client can be used for clearing responses from Mirage
+
+  Background:
+    Given the following gems are required to run the Mirage client test code:
+    """
+    require 'rubygems'
+    require 'rspec'
+    require 'mirage'
+    """
+    And I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+
+    And I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Hello there
+    """
+    And I hit 'http://localhost:7001/mirage/set/leaving' with parameters:
+      | response | Goodbye |
+
+    And I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    I'm going
+    """
+
+  Scenario: Clearing everything
+    When I run
+    """
+    Mirage::Client.new.clear
+    """
+    And I hit 'http://localhost:7001/mirage/get/greeting'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+    And I hit 'http://localhost:7001/mirage/get/leaving'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/check/2'
+    Then a 404 should be returned
+
+
+  Scenario: Clearing all requests
+    When I run
+    """
+    Mirage::Client.new.clear :requests
+    """
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/check/2'
+    Then a 404 should be returned
+
+  Scenario: Clearning a response
+    Given I run
+    """
+    Mirage::Client.new.clear 1
+    """
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then a 404 should be returned
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+  Scenario: Clearning a request
+    Given I run
+    """
+    Mirage::Client.new.clear :request => 1
+    """
+    When I hit 'http://localhost:7001/mirage/check/1'
+    Then a 404 should be returned
+
+
+
+
+