mirage 0.1.2

data/features/root_responses.feature

@@ -0,0 +1,47 @@
+Feature: Mirage can respond with a 'root' response when a when the response requested at a sub url is not found.
+  I.e.
+  if a response is held for 'level1' and request comes in for 'level1/level2' the response for 'level1'
+  can be returned if nothing is held for 'level1/level2'
+
+  If a request is made and there is more than one response that could be appropriate then the closet is chosen.
+
+  E.g.
+  responses exist for: 'level1' and 'level1/level2'. If a response for 'level1/level2/level3 is made, then the response for
+  'level1/level2' will be returned as it is the most specific match out of the two.
+
+  Root responses can cause unexpected behaviour and so in order to qualify as a root reponse a client must knowingly mark it as one.
+
+  Scenario: A root response is returned
+    Given I hit 'http://localhost:7001/mirage/set/level0/level1' with parameters:
+      | response | another level |
+    And I hit 'http://localhost:7001/mirage/set/level1' with parameters:
+      | response      | level 1 |
+      | root_response | true    |
+
+    When I hit 'http://localhost:7001/mirage/get/level1/level2'
+    Then 'level 1' should be returned
+
+
+  Scenario: More than one potential root response exists
+    Given I hit 'http://localhost:7001/mirage/set/level1' with parameters:
+      | response      | level 1 |
+      | root_response | true    |
+    And I hit 'http://localhost:7001/mirage/set/level1/level2' with parameters:
+      | response      | level 2 |
+      | root_response | true    |
+    And I hit 'http://localhost:7001/mirage/set/level1/level2/level3' with parameters:
+      | response      | level 3 |
+      | root_response | false   |
+    And I hit 'http://localhost:7001/mirage/set/level1/level2/level3/level4/level5' with parameters:
+      | response      | level 5 |
+      | root_response | true    |
+
+    When I hit 'http://localhost:7001/mirage/get/level1/level2/level3/level4'
+    Then 'level 2' should be returned
+
+
+  Scenario: There isnt a root response
+    Given I hit 'http://localhost:7001/mirage/set/level1' with parameters:
+      | response | level 1 |
+    When I hit 'http://localhost:7001/mirage/get/level1/level2'
+    Then a 404 should be returned

data/features/setting_responses.feature

@@ -0,0 +1,40 @@
+Feature: Mirage can be configured with endpoints that when request returned defined responses.
+  On setting a response, a unique id is retuned. This is a key that can be used to manage the response. E.g. clearing or peek at it.
+
+  Usage:
+  ${mirage_url}/set/your/end/point?response=your_response
+
+
+  Scenario: Setting a response without any selection criteria
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello, how are you? |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'Hello, how are you?' should be returned
+
+  Scenario: A response hosted on a longer url
+    Given I hit 'http://localhost:7001/mirage/set/say/hello/to/me' with parameters:
+      | response | Hello to me |
+
+    When I hit 'http://localhost:7001/mirage/get/say/hello/to/me'
+    Then 'Hello to me' should be returned
+
+
+  Scenario: The same endpoint is set more than once
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello |
+    Then '1' should be returned
+
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hi |
+    Then '1' should be returned
+
+
+  Scenario: A response is not supplied
+    Given I hit 'http://localhost:7001/mirage/set/greeting'
+    Then a 500 should be returned
+
+
+  Scenario: Getting a response that does not exist
+    When I hit 'http://localhost:7001/mirage/get/response_that_does_not_exist'
+    Then a 404 should be returned

data/features/setting_responses_with_a_delay.feature

@@ -0,0 +1,10 @@
+Feature: Its possible introduce a delay before responding to a client with a particular response. This lets you simulate real world
+  conditions by making your application wait before receiving a response.
+
+  Scenario: Response with a delay
+    Given I hit 'http://localhost:7001/mirage/set/an_appology' with parameters:
+      | response | Sorry it took me so long! |
+      | delay    | 4                         |
+
+    When I hit 'http://localhost:7001/mirage/get/an_appology'
+    Then it should take at least '4' seconds

data/features/setting_responses_with_pattern_matching.feature

@@ -0,0 +1,72 @@
+Feature: Mirage can be configured to return particular responses conditionally based on if a prescribed pattern is found in
+  querystring or the body of a request.
+
+  Patterns can be either plain text or a regular expression
+
+  Background: There is already a default response for 'greeting'
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Stranger. |
+
+
+  Scenario: A plain text pattern found in the request body
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon, how are you? |
+      | pattern  | <name>leon</name>        |
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+     <greetingRequest>
+      <name>leon</name>
+     </greetingRequest>
+    """
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario: A regex based pattern found in the request body
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon, how are you? |
+      | pattern  | .*?leon<\/name>          |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+     <greetingRequest>
+      <name>leon</name>
+     </greetingRequest>
+    """
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario: A plain text pattern found in the query string
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon, how are you? |
+      | pattern  | leon                     |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | name | leon |
+
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario:  A regex based pattern found in the query string
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon, how are you? |
+      | pattern  | name=[L\|l]eon           |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with parameters:
+      | name | leon |
+
+    Then 'Hello Leon, how are you?' should be returned
+
+
+  Scenario: The pattern is not matched
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Hello Leon, how are you? |
+      | pattern  | .*?leon<\/name>          |
+
+    When I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+     <greetingRequest>
+      <name>jim</name>
+     </greetingRequest>
+    """
+
+    Then 'Hello Stranger.' should be returned

data/features/snapshotting.feature

@@ -0,0 +1,25 @@
+Feature: Having set up the Mirage with a number of defaults, your tests may continue to change its state.
+  Clearing and resetting all of your responses, potentially hundreds of times, can be time expensive.
+
+  Mirage provides the ability to take a snapshot of its current state and to roll it back to that state.
+
+  Background: The MockServer has been setup with some default responses
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | The default greeting |
+
+
+  Scenario: Taking a snapshot and rolling it back
+    Given  I hit 'http://localhost:7001/mirage/snapshot'
+    And I hit 'http://localhost:7001/mirage/set/leaving' with parameters:
+      | response | Goodye |
+
+    And I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response | Changed |
+
+    And I hit 'http://localhost:7001/mirage/rollback'
+
+    When I hit 'http://localhost:7001/mirage/get/leaving'
+    Then a 404 should be returned
+
+    When I hit 'http://localhost:7001/mirage/get/greeting'
+    Then 'The default greeting' should be returned

data/features/step_definitions/my_steps.rb

@@ -0,0 +1,127 @@
+Before('@command_line') do
+  stop_mirage
+end
+
+After('@command_line') do
+  stop_mirage
+end
+
+Then /^'(.*?)' should be returned$/ do |expected_response|
+  response_text = @response.body
+  if ["1.8.6", "1.8.7"].include?(RUBY_VERSION) && response_text != expected_response
+    expected_response.length.should == response_text.length
+    expected_response.split('&').each { |param_value_pair| response_text.should =~ /#{param_value_pair}/ }
+  else
+    response_text.should == expected_response
+  end
+end
+
+Then /^a (404|500) should be returned$/ do |error_code|
+  @response.code.should == error_code.to_i
+end
+
+Then /^it should take at least '(.*)' seconds$/ do |time|
+  (@response_time).should >= time.to_f
+end
+
+
+Then /^the response should be a file the same as '([^']*)'$/ do |file_path|
+  download_path = "#{SCRATCH}/temp.download"
+  @response.save_as(download_path)
+  FileUtils.cmp(download_path, file_path).should == true
+end
+
+Then /^mirage should be running on '(.*)'$/ do |url|
+  get(url).code.to_i.should == 200
+end
+
+Given /^I run '(.*)'$/ do |command|
+  path = ENV['mode'] == 'regression' ? '' : "../bin/"
+  @commandline_output = normalise(IO.popen("export RUBYOPT='' && cd #{SCRATCH} && #{path}#{command}").read)
+end
+
+Given /^Mirage (is|is not) running$/ do |running|
+  if running == 'is'
+    start_mirage unless $mirage.running?
+  else
+    stop_mirage if $mirage.running?
+  end
+end
+
+Then /^Connection should be refused to '(.*)'$/ do |url|
+
+  begin
+    get(url)
+    fail "Mirage is still running"
+  rescue Errno::ECONNREFUSED
+  end
+
+end
+
+Given /^the file '(.*)' contains:$/ do |file_path, content|
+  file_path = "#{SCRATCH}/#{file_path}" unless file_path =~ /^\//
+
+  FileUtils.rm_rf(file_path) if File.exists?(file_path)
+  directory = File.dirname(file_path)
+  FileUtils.mkdir_p(directory)
+  file = File.new("#{directory}/#{File.basename(file_path)}", 'w')
+  file.write(content)
+  file.close
+end
+
+Then /^the usage information should be displayed$/ do
+  @usage.each { |line| @commandline_output.should =~ /#{line}/ }
+end
+Given /^usage information:$/ do |table|
+  @usage = table.raw.flatten.collect { |line| normalise(line) }
+end
+
+Then /^I run$/ do |text|
+  text.gsub!("\"", "\\\\\"")
+  raise "run failed" unless system "#{RUBY_CMD} -e \"#{@code_snippet}\n#{text}\""
+end
+
+Given /^the following gems are required to run the Mirage client test code:$/ do |text|
+  @code_snippet = text.gsub("\"", "\\\\\"")
+end
+
+When /^I hit '(http:\/\/localhost:7001\/mirage\/(.*?))'$/ do |url, response_id|
+  @response = hit_mirage(url)
+end
+
+When /^I (hit|get|post to) '(http:\/\/localhost:7001\/mirage\/(.*?))' with parameters:$/ do |http_method, url, endpoint, table|
+
+  parameters = {}
+  table.raw.each do |row|
+    parameter, value = row[0].to_sym, row[1]
+    value = (parameter == :file ? File.open(value) : value)
+    parameters[parameter.to_sym]=value
+  end
+
+  @response = hit_mirage(url, parameters)
+end
+
+When /^I hit '(http:\/\/localhost:7001\/mirage\/(.*?))' with request body:$/ do |url, endpoint, request_body|
+  @response = hit_mirage(url, {:body => request_body})
+end
+
+Then /^I should see '(.*?)' on the command line$/ do |content|
+  @commandline_output.should =~/#{content}/
+end
+
+Then /^'(.*)' should exist$/ do |path|
+  File.exists?("#{SCRATCH}/#{path}").should == true
+end
+
+Then /^'(.*)' should contain '(.*)'$/ do |file, content|
+  fail("#{content} not found in: #{File.read(file)}") unless File.read("#{SCRATCH}/#{file}").index(content)
+end
+Given /^I goto '(.*)'$/ do |url|
+  @page = Mechanize.new.get url
+end
+Then /^I should see '(.*)'$/ do |text|
+  @page.body.index(text).should_not == nil
+end
+When /^I click '(.*)'$/ do |thing|
+  @page = @page.links.find{|link| link.attributes['id'] == thing}.click
+end

data/features/support/env.rb

@@ -0,0 +1,89 @@
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../../lib")
+require 'rubygems'
+require 'bundler/setup'
+Bundler.setup(:test)
+require 'mirage'
+require 'cucumber'
+require 'rspec'
+require 'mechanize'
+
+SCRATCH = './scratch'
+RUBY_CMD = RUBY_PLATFORM == 'JAVA' ? 'jruby' : 'ruby'
+
+
+module Web
+  include Mirage::Web
+
+  def get(url)
+    browser = Mechanize.new
+    browser.keep_alive= false
+    browser.get(url)
+  end
+
+  def hit_mirage(url, parameters={})
+    start_time = Time.now
+    response = (parameters.include?(:file) ? http_post(url, parameters) : http_get(url, parameters))
+    @response_time = Time.now - start_time
+    response
+  end
+
+  def normalise text
+    text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ')
+  end
+end
+
+
+module Regression
+  def stop_mirage
+    `export RUBYOPT='' && cd #{SCRATCH} && mirage stop`
+  end
+
+  def start_mirage
+    `truncate mirage.log --size 0`
+    `export RUBYOPT='' && cd #{SCRATCH} && mirage start`
+  end
+end
+
+module IntelliJ
+  include Mirage::Util
+
+  def stop_mirage
+    system "cd #{SCRATCH} && ../bin/mirage stop"
+    wait_until do
+      !$mirage.running?
+    end
+  end
+
+  def start_mirage
+    puts "starting mirage"
+    `truncate mirage.log --size 0`
+    system "cd #{SCRATCH} && ../bin/mirage start"
+
+    wait_until do
+      $mirage.running?
+    end
+  end
+end
+
+'regression' == ENV['mode'] ? World(Regression) : World(IntelliJ)
+'regression' == ENV['mode'] ? include(Regression) : include(IntelliJ)
+
+World(Web)
+
+Before do
+  FileUtils.mkdir_p(SCRATCH)
+  $mirage = Mirage::Client.new
+
+  if $mirage.running?
+    $mirage.clear
+  else
+    start_mirage
+  end
+  
+  `ls #{SCRATCH}/ | grep -v mirage.log | rm -rf`
+  `truncate -s 0 #{SCRATCH}/mirage.log`
+end
+
+at_exit do
+  stop_mirage
+end

data/features/web_user_interface.feature

@@ -0,0 +1,39 @@
+Feature: Mirage's home page allows you to see what response are currently being hosted.
+  From this page you can:
+  - Peek at a responses content
+  - Check the response to see if a request has been made to it
+
+  Background: There are already a couple of responses hosted on he Mirage server
+    Given I hit 'http://localhost:7001/mirage/set/greeting' with parameters:
+      | response      | hello |
+      | root_response | true  |
+    And I hit 'http://localhost:7001/mirage/set/leaving' with parameters:
+      | response | goodbye |
+
+  Scenario: Using the home page to see what response are being hosted
+    Given I goto 'http://localhost:7001/mirage'
+    Then I should see 'greeting/*'
+    Then I should see 'leaving'
+
+  Scenario: Using the home page to peek at a response
+    Given I goto 'http://localhost:7001/mirage'
+    When  I click 'peek_response_1'
+    Then I should see 'hello'
+
+  Scenario: Using the home page to check if a request has been made
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Yo!
+    """
+    Given I goto 'http://localhost:7001/mirage'
+    When  I click 'check_response_1'
+    Then I should see 'Yo!'
+
+  Scenario: Using the home page to check if a request has been made
+    Given I hit 'http://localhost:7001/mirage/get/greeting' with request body:
+    """
+    Yo!
+    """
+    Given I goto 'http://localhost:7001/mirage'
+    When  I click 'check_response_1'
+    Then I should see 'Yo!'