mirage 3.0.13 → 3.0.14

data/features/step_definitions/observation_steps.rb

@@ -1,102 +0,0 @@
-Then /^'([^']*)' should be returned$/ do |expected_response|
-  response_text = @response.body
-  if response_text != expected_response
-    expected_response.split('&').each { |param_value_pair| response_text.should =~ /#{param_value_pair}/ }
-    expected_response.length.should == response_text.length
-  end
-end
-
-Then /^a (\d+) should be returned$/ do |error_code|
-  @response.code.to_i.should == error_code.to_i
-end
-
-Then /^it should take at least '(.*)' seconds$/ do |time|
-  (@response_time).should >= time.to_f
-end
-
-Then /^mirage (should|should not) be running on '(.*)'$/ do |should, url|
-  running = begin
-    get(url).code.to_i.should == 200
-  rescue
-    false
-  end
-
-  should == "should" ? running.should == true : running.should == false
-end
-
-Given /^Mirage (is|is not) running$/ do |running|
-  if running == 'is'
-    start_mirage_in_scratch_dir unless Mirage.running?
-  else
-    Mirage.stop :all
-  end
-end
-
-Then /^the usage information should be displayed$/ do
-  @usage.each_line { |line| @commandline_output.should include(line) }
-end
-
-Then /^I should see '(.*?)' on the command line$/ do |content|
-  @commandline_output.should include(content)
-end
-
-Then /^'(.*)' should exist$/ do |path|
-  File.exists?("#{SCRATCH}/#{path}").should == true
-end
-
-Then /^mirage.log should contain '(.*)'$/ do |content|
-  log_file_content = @mirage_log_file.readlines.to_s
-  fail("#{content} not found in mirage.log: #{log_file_content}") unless log_file_content.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 /^the response '([^']*)' should be '([^']*)'$/ do |header, value|
-  @response.response[header].should include(value)
-end
-
-Then /^request data should have been retrieved$/ do
-  request_data = JSON.parse(@response.body)
-  request_data.include?('parameters').should == true
-  request_data.include?('headers').should == true
-  request_data.include?('body').should == true
-  request_data.include?('request_url').should == true
-  request_data.include?('id').should == true
-end
-
-Then(/^the template (request|response) specification should have the following set:$/) do |spec, table|
-  template_json = JSON.parse(get("http://localhost:7001/templates/#{JSON.parse(@response.body)['id']}").body)
-  request_specification = template_json[spec]
-  request_specification.size.should==table.hashes.size
-  table.hashes.each do |hash|
-    default = request_specification[hash['Setting'].downcase.gsub(' ', '_')]
-    case required_default = hash['Default']
-      when 'none'
-        case default
-          when Array
-            default.should == []
-          when Hash
-            default.should == {}
-          else
-            default.should == ""
-
-        end
-      else
-        default.to_s.downcase.should == required_default.downcase
-    end
-  end
-end
-
-Then(/^the following json should be returned:$/) do |text|
-  JSON.parse(text).should == JSON.parse(@response.body)
-end
-
-When(/^the content-type should be '(.*)'$/) do |content_type|
-  @response.content_type.should == content_type
-end

data/features/support/command_line.rb

@@ -1,37 +0,0 @@
-require 'tempfile'
-require 'wait_methods'
-
-module CommandLine
-  include Mirage::WaitMethods
-
-  def run command
-    output = Tempfile.new("child")
-    Dir.chdir SCRATCH do
-      process = ChildProcess.build(*("#{command}".split(' ')))
-      process.detach
-      process.io.stdout = output
-      process.io.stderr = output
-      process.start
-      wait_until(:timeout_after => 30) { process.exited? }
-    end
-    File.read(output.path)
-  end
-
-  def normalise text
-    text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ').strip
-  end
-
-  def write_to_file file_path, content
-    file_path = "#{SCRATCH}/#{file_path}" unless file_path =~ /^\//
-
-    FileUtils.rm_rf(file_path) if File.exists?(file_path)
-    FileUtils.mkdir_p(File.dirname(file_path))
-
-    File.open("#{file_path}", 'w') do |file|
-      file.write(content)
-    end
-  end
-end
-
-World CommandLine
-include CommandLine

data/features/support/env.rb

@@ -1,22 +0,0 @@
-ROOT_DIR = File.expand_path("#{File.dirname(__FILE__)}/../..")
-SOURCE_PATH = "#{ROOT_DIR}/lib"
-Bundler.require
-
-$LOAD_PATH.unshift(SOURCE_PATH)
-require 'base64'
-require 'mirage/client'
-
-SCRATCH = "#{ROOT_DIR}/scratch"
-RUBY_CMD = ChildProcess.jruby? ? 'jruby' : 'ruby'
-BLANK_RUBYOPT_CMD = ChildProcess.windows? ? 'set RUBYOPT=' : "export RUBYOPT=''"
-ENV['RUBYOPT'] = ''
-
-
-if 'regression' == ENV['mode']
-  MIRAGE_CMD = ChildProcess.windows? ? `where mirage.bat`.chomp : 'mirage'
-else
-  MIRAGE_CMD = "#{RUBY_CMD} ../bin/mirage"
-end
-
-
-

data/features/support/hooks.rb

@@ -1,26 +0,0 @@
-Before do
-  FileUtils.mkdir_p(SCRATCH)
-
-  mirage.templates.delete_all
-
-  Dir["#{SCRATCH}/*"].each do |file|
-    FileUtils.rm_rf(file) unless file == "#{SCRATCH}/mirage.log"
-  end
-
-  if File.exists? "#{SCRATCH}/mirage.log"
-    @mirage_log_file = File.open("#{SCRATCH}/mirage.log")
-    @mirage_log_file.seek(0, IO::SEEK_END)
-  end
-end
-
-Before ('@command_line') do
-  Mirage.stop :all
-end
-
-After('@command_line') do
-  Mirage.stop :all
-end
-
-at_exit do
-  Mirage.stop :all
-end

data/features/support/mirage.rb

@@ -1,12 +0,0 @@
-module Mirage
-  def start_mirage_in_scratch_dir
-    Dir.chdir SCRATCH do
-      Mirage.start
-    end
-  end
-
-  def mirage
-    @mirage ||= Mirage.running? ? Mirage::Client.new : start_mirage_in_scratch_dir
-  end
-end
-World Mirage

data/features/support/web.rb

@@ -1,19 +0,0 @@
-require 'httparty'
-module Mirage
-  module Web
-    def get *args
-      HTTParty.get(*args)
-    end
-    def put *args
-      HTTParty.put(*args)
-    end
-    def post *args
-      HTTParty.post(*args)
-    end
-    def delete *args
-      HTTParty.delete(*args)
-    end
-  end
-end
-
-World(Mirage::Web)

data/features/templates/delete.feature

@@ -1,45 +0,0 @@
-Feature: Deleting
-  When a template is deleted, any tracked request data is also removed.
-
-  Background: The MockServer has already got a response for greeting and leaving on it.
-    Given the following template template:
-    """
-      {
-         "response":{
-            "body":"Hello"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/greeting'
-
-    Given the following template template:
-    """
-      {
-         "response":{
-            "body":"Goodbye"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/leaving'
-
-
-  Scenario: Deleting all templates
-    Given DELETE is sent to '/templates'
-    When GET is sent to '/responses/greeting'
-    Then a 404 should be returned
-    When GET is sent to '/responses/leaving'
-    Then a 404 should be returned
-
-
-  Scenario: Deleting a particular template
-    Given DELETE is sent to '/templates/1'
-
-    When GET is sent to '/responses/greeting'
-    Then a 404 should be returned
-
-    When GET is sent to '/responses/leaving'
-    Then a 200 should be returned
-
-    

data/features/templates/get.feature

@@ -1,54 +0,0 @@
-Feature: Retrieving
-  Templates can be retrieved by using the ID that was returned when they were created
-
-
-  Scenario: Retrieving a template
-    Given the following template template:
-    """
-      {
-         "response":{
-            "default":false,
-            "body":"Hello",
-            "delay":0,
-            "content_type":"text/plain",
-            "status":200
-         },
-         "request":{
-            "parameters":{
-
-            },
-            "body_content":[
-
-            ],
-            "http_method":"get"
-         }
-      }
-    """
-    And the template is sent using PUT to '/templates/greeting'
-    When GET is sent to '/templates/1'
-    Then the following json should be returned:
-    """
-      {
-         "id": 1,
-         "endpoint": "greeting",
-         "requests_url": "http://localhost:7001/requests/1",
-         "response":{
-            "default":false,
-            "body":"Hello",
-            "delay":0,
-            "content_type":"text/plain",
-            "status":200
-         },
-         "request":{
-            "parameters":{
-
-            },
-            "headers":{},
-            "body_content":[
-            ],
-            "http_method":"get"
-         }
-      }
-    """
-
-

data/features/templates/path_wildcards.feature

@@ -1,10 +0,0 @@
-Feature: URI wildcards
-
-  Scenario: Setting a template with wildcards
-    Given the following Template JSON:
-    """
-    {"response":{"body":"SGVsbG8="}}
-    """
-    And the template is sent using PUT to '/templates/greeting/*/davis'
-    When GET is sent to '/responses/greeting/leon/davis'
-    Then 'Hello' should be returned

data/features/templates/preview.feature

@@ -1,18 +0,0 @@
-Feature: Previewing
-  A Template's body can be previewed
-
-
-  Scenario: Preview template body
-    Given the following template template:
-    """
-      {
-         "response":{
-            "body":"SGVsbG8="
-         },
-         "request":{
-         }
-      }
-    """
-    And the template is sent using PUT to '/templates/greeting'
-    When GET is sent to '/templates/1/preview'
-    Then 'Hello' should be returned

data/features/templates/put.feature

@@ -1,77 +0,0 @@
-Feature: Creating a Template
-  Mirage can be configured with Templates. Templates describe the characteristics of responses that should be returned to a client. In addition to this a templates also describe the conditions under which a template may be used to generate a response.
-
-  On setting a template, a unique id is returned. This is a key that can be used to manage the Template.
-
-  Templates can be configured to respond to either, GET, POST, PUT, or DELETE.
-
-  More than one Template can be placed at the same resource address as long as they have different request contraints. In this case they are given different IDs. For example if two templates are configured to respond to request using different HTTP methods then they will not overwrite each other but both be stored.
-
-  Requirements can be specified as required when configuring a Template:
-  * request parameters
-  * body content
-  * HTTP Headers
-  * HTTP Method
-
-  The following attributes of a response can be configured
-  * HTTP status code
-  * Whether this template is to be treated as the default response if a match is not found for a sub URI
-  * A delay before the response is returned to the client. This is in seconds and floats are accepted
-  * Content-Type
-
-  Things to note:
-  ---------------
-  The body attribute of the response should be Base64 encoded. This is so that you may specify binary data if that is what you would like to send back to clients.
-
-
-  Scenario: Setting a Template on Mirage
-    Given the following Template JSON:
-    """
-      {
-         "request":{
-            "parameters":{},
-            "http_method":"get",
-            "headers": {},
-            "body_content":[]
-         },
-         "response":{
-            "default":false,
-            "body":"SGVsbG8=",
-            "delay":0,
-            "content_type":"text/plain",
-            "status":200
-         }
-      }
-    """
-    When the template is sent using PUT to '/templates/greeting'
-    Then '{"id":1}' should be returned
-
-    When GET is sent to '/responses/greeting'
-    Then 'Hello' should be returned
-    And a 200 should be returned
-
-
-  Scenario: Template defaults
-    Given the following Template JSON:
-    """
-    {}
-    """
-    When the template is sent using PUT to '/templates/greeting'
-    Then the template request specification should have the following set:
-      | Setting      | Default |
-      | parameters   | none    |
-      | body content | none    |
-      | headers      | none    |
-      | HTTP method  | GET     |
-    And the template response specification should have the following set:
-      | Setting      | Default    |
-      | default      | false      |
-      | body         | none       |
-      | content_type | text/plain |
-      | delay        | 0          |
-      | status       | 200        |
-
-  Scenario: Making a request that is unmatched
-    When GET is sent to '/responses/unmatched'
-    Then a 404 should be returned
-

data/features/templates/put_with_substitutions.feature

@@ -1,22 +0,0 @@
-Feature: Substituting values from requests in to a template
-  Parts of a response can be substituted for values found in the request body or query string.
-  This allows dynamic content to be sent back to a client.
-
-  To do this, substitution, matchers must be put in the the response value.
-
-  Either a string literal or a regex can be used in between ${} to find a match
-
-  Scenario: A response template populated from matches found in the request body using a regex
-    Given the following template template:
-    """
-      {
-         "response":{
-            "body":"Hello ${name}"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/greeting'
-    When I send GET to '/responses/greeting' with parameters:
-      |name|Joe  |
-    Then 'Hello Joe' should be returned