mirage 3.0.13 → 3.0.14

data/features/client/start.feature

@@ -1,46 +0,0 @@
-@command_line
-Feature: Starting Mirage
-
-  The client can be used to start Mirage.
-
-  Both the port and default templates directory can be specified
-
-  On starting Mirage a client is returned.
-
-
-  Background:
-    Given the following require statements are needed:
-    """
-    require 'rubygems'
-    require 'mirage/client'
-    """
-
-  Scenario: Starting Mirage on the default port
-    When I run
-    """
-    Mirage.start
-    """
-    Then mirage should be running on 'http://localhost:7001'
-
-
-  Scenario: Starting Mirage on a custom port
-    When I run
-    """
-    Mirage.start :port => 9001
-    """
-    Then mirage should be running on 'http://localhost:9001'
-
-
-  Scenario: Specifying a custom templates directory.
-    And the file './custom_responses_location/default_greetings.rb' contains:
-    """
-    prime do |mirage|
-      mirage.templates.put('greeting', 'hello')
-    end
-    """
-    When I run
-    """
-    Mirage.start :defaults => './custom_responses_location'
-    """
-    And GET is sent to '/responses/greeting'
-    Then 'hello' should be returned

data/features/client/stop.feature

@@ -1,53 +0,0 @@
-@command_line
-Feature: Stopping Mirage
-
-  The client API can be used to stop instances of Mirage running on localhost.
-
-  Background:
-    Given the following require statements are needed:
-    """
-    require 'rubygems'
-    require 'mirage/client'
-    """
-
-  Scenario: Stopping Mirage
-    Given Mirage is running
-    When I run
-    """
-    Mirage.stop
-    """
-    Then mirage should not be running on 'http://localhost:7001'
-
-
-  Scenario: Stopping Mirage on custom port
-    And I run 'mirage start -p 9001'
-    When I run
-    """
-    Mirage.stop :port => 9001
-    """
-    Then mirage should not be running on 'http://localhost:9001'
-
-  Scenario: Stopping multiple instances of Mirage
-    Given I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    And I run 'mirage start -p 10001'
-    When I run
-    """
-    Mirage.stop :port => [9001,10001]
-    """
-    Then mirage should be running on 'http://localhost:7001'
-    Then mirage should not be running on 'http://localhost:9001'
-    Then mirage should not be running on 'http://localhost:10001'
-
-
-  Scenario: Stopping all instances of Mirage
-    Given I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    And I run 'mirage start -p 10001'
-    When I run
-    """
-    Mirage.stop :all
-    """
-    Then mirage should not be running on 'http://localhost:7001'
-    Then mirage should not be running on 'http://localhost:9001'
-    Then mirage should not be running on 'http://localhost:10001'

data/features/commandline_interface/help.feature

@@ -1,17 +0,0 @@
-@command_line
-Feature: Help
-  Mirage is started from the command line. Mirage logs to mirage.log at the path where Mirage is started from.
-
-
-  Background: Mirage usage
-    Given usage information:
-    """
-      mirage help [COMMAND]  # Describe available commands or one specific command
-      mirage start        # Starts mirage
-      mirage stop         # Stops mirage
-    """
-
-
-  Scenario: Starting with help option
-    Given I run 'mirage help'
-    Then the usage information should be displayed

data/features/commandline_interface/readme.md

@@ -1 +0,0 @@
-Mirage has a fully functional commandline interface check it out!

data/features/commandline_interface/start.feature

@@ -1,18 +0,0 @@
-@command_line
-Feature: Starting Mirage
-  Mirage is started from the command line. more than instance of Mirage can be started on different ports at the same time.
-
-  By default mirage runs on port 7001.
-
-
-  Scenario: Starting mirage
-    Given Mirage is not running
-    When I run 'mirage start'
-    Then mirage should be running on 'http://localhost:7001'
-    And 'mirage.log' should exist
-
-
-  Scenario: Starting Mirage on a custom port
-    Given Mirage is not running
-    When I run 'mirage start -p 9001'
-    Then mirage should be running on 'http://localhost:9001'

data/features/commandline_interface/stop.feature

@@ -1,42 +0,0 @@
-@command_line
-Feature: Stopping Mirage
-  Mirage can be stopped from the commandline
-  If more than one instance of Mirage is running, you will be asked to supply the ports which represent the running instances
-  of mirage that you wish to stop.
-
-  Scenario: Stopping a single instance of Mirage
-    Given I run 'mirage start -p 7001'
-    When I run 'mirage stop'
-    Then mirage should not be running on 'http://localhost:7001'
-
-  Scenario: Stopping an instance running on a given port
-    Given I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    When I run 'mirage stop -p 7001'
-    Then mirage should be running on 'http://localhost:9001'
-    Then mirage should not be running on 'http://localhost:7001'
-
-  Scenario: Stopping more than one instance
-    Given I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    And I run 'mirage start -p 10001'
-    When I run 'mirage stop -p 7001 9001'
-    Then mirage should be running on 'http://localhost:10001'
-    Then mirage should not be running on 'http://localhost:7001'
-    Then mirage should not be running on 'http://localhost:9001'
-
-  Scenario: Stopping all running instances
-    Given I run 'mirage start -p 7001'
-    And I run 'mirage start -p 9001'
-    When I run 'mirage stop -p all'
-    Then mirage should not be running on 'http://localhost:10001'
-    Then mirage should not be running on 'http://localhost:7001'
-    Then mirage should not be running on 'http://localhost:9001'
-
-  Scenario: Calling stop when there is more than one instance running
-    Given I run 'mirage start -p 7001'
-    Given I run 'mirage start -p 9001'
-    When I run 'mirage stop'
-    Then I should see 'Mirage is running on ports 7001, 9001. Please run mirage stop -p [PORT(s)] instead' on the command line
-    And mirage should be running on 'http://localhost:7001'
-    And mirage should be running on 'http://localhost:9001'

data/features/logging.feature

@@ -1,6 +0,0 @@
-Feature: Output from Mirage is stored in mirage.log.
-  This file is located at the root from which mirage is started.
-
-  Scenario: Mirage logs request
-    Given GET is sent to '/templates/greeting'
-    Then mirage.log should contain '/templates/greeting'

data/features/prime.feature

@@ -1,35 +0,0 @@
-#TODO - rename responses directory to templates
-@command_line
-Feature: Preloading Templates
-  Mirage can be primed with a set of templates.
-  By default, Mirage loads any .rb files found in ./mirage on startup. Mirage can also be made to load responses from a directory
-  of your choosing by using the -d/--defaults option
-
-  Responses can be added to the responses directory and used to prime Mirage after Mirage has been started.
-
-  Priming causes any modifications to Mirage's current state to be lost.
-
-
-  Scenario: Using the default responses directory
-    Given the file 'mirage/default_greetings.rb' contains:
-    """
-    prime do |mirage|
-      mirage.templates.put('greeting', 'hello')
-    end
-    """
-    And I run 'mirage start'
-    When GET is sent to '/responses/greeting'
-    Then 'hello' should be returned
-
-
-  Scenario: Using a custom responses directory
-    Given Mirage is not running
-    And the file '/tmp/mirage/default_greetings.rb' contains:
-    """
-    prime do |mirage|
-      mirage.templates.put('greeting', 'hello')
-    end
-    """
-    And I run 'mirage start --defaults /tmp/mirage'
-    And GET is sent to '/responses/greeting'
-    Then 'hello' should be returned

data/features/readme.md

@@ -1,7 +0,0 @@
-Mirage in an open source project that can be used to mock HTTP services. It facilitates application development in environments where external systems aren't easily accessed or can't be made to behave in a repeatable way.
-
-At its core, Mirage is a web application with a restful interface that can be configured with responses. The descriptors for these response are called [Templates](/lashd/mirage/docs/templates).
-
-If you're using Ruby then Mirage has a [client](/lashd/mirage/docs/client) to get you going straight away.
-
-If you're using another language, then the interface to Mirage is simple and it would be great to see clients emerging other languages too. If you need any help please ask! :)

data/features/requests/delete.feature

@@ -1,48 +0,0 @@
-Feature: Deleting tracked requests
-  Tracked request data can be deleted
-
-  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'
-
-
-    And GET is sent to '/responses/greeting'
-    And GET is sent to '/responses/leaving'
-
-    
-  Scenario: Deleting all requests
-    And DELETE is sent to '/requests'
-
-    When GET is sent to '/requests/1'
-    Then a 404 should be returned
-    When GET is sent to '/requests/2'
-    Then a 404 should be returned
-
-
-
-  Scenario: Deleting a stored request for a particular response
-    And DELETE is sent to '/requests/1'
-
-    When GET is sent to '/requests/1'
-    Then a 404 should be returned
-    When GET is sent to '/requests/2'
-    Then a 200 should be returned

data/features/requests/get.feature

@@ -1,36 +0,0 @@
-Feature: Checking tracked requests
-  After a response has been served from Mirage, the request that triggered it can be retrieved. This is useful
-  for testing that the correct information was sent by your application code.
-
-  Use a template's ID to retrieve the last request that was last received.
-
-
-  Background: A template has already be put on Mirage
-    Given the following template template:
-    """
-      {
-         "request" : {
-            "http_method" : "post"
-         },
-         "response":{
-            "body":"Hello"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/greeting'
-
-
-  Scenario: Getting request data when the data was in the body.
-    Given I send POST to '/responses/greeting' with request entity
-    """
-    Hello Mirage
-    """
-    When GET is sent to '/requests/1'
-    Then request data should have been retrieved
-
-
-  Scenario: Getting request data for a template that has not yet served a response.
-    Given GET is sent to '/requests/1'
-    Then a 404 should be returned
-

data/features/save_and_revert.feature

@@ -1,35 +0,0 @@
-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 save its current state and to revert back to that state.
-
-  Background: The MockServer has been setup with some default responses
-    Given the following template template:
-    """
-      {
-         "response":{
-            "body":"The default greeting"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/greeting'
-
-    
-  Scenario: Saving Mirage and reverting it
-    Given PUT is sent to '/backup'
-    And the following template template:
-    """
-      {
-         "response":{
-            "body":"Changed"
-         }
-      }
-    """
-    And 'response.body' is base64 encoded
-    And the template is sent using PUT to '/templates/greeting'
-    
-    When PUT is sent to '/'
-    And GET is sent to '/responses/greeting'
-
-    Then 'The default greeting' should be returned

data/features/step_definitions/my_steps.rb

@@ -1,97 +0,0 @@
-Given /^I run '(.*)'$/ do |command|
-  if ENV['mode'] == 'regression' && ChildProcess.windows?
-    command.gsub!(/^mirage/, MIRAGE_CMD)
-  else
-    path = "#{RUBY_CMD} ../bin/"
-  end
-
-  @commandline_output = normalise(run("#{path}#{command}"))
-end
-
-Given /^the file '(.*)' contains:$/ do |file_path, content|
-  write_to_file file_path, content
-end
-
-Given /^usage information:$/ do |usage|
-  @usage = normalise(usage.to_s)
-end
-
-Then /^I run$/ do |text|
-  text.gsub!("\"", "\\\\\"")
-  Dir.chdir SCRATCH do
-    raise "run failed" unless system "#{RUBY_CMD} -I #{SOURCE_PATH} -e \"#{@code_snippet}\n#{text}\""
-  end
-end
-
-Given /^the following require statements are needed:$/ do |text|
-  @code_snippet = text.gsub("\"", "\\\\\"")
-end
-
-When /^I send (POST|PUT) to '(.*)' with request entity$/ do |method, endpoint, entity|
-  url = "http://localhost:7001#{endpoint}"
-  @response = case method
-                when 'POST'
-                  post(url, body: entity)
-                when 'PUT'
-                  put(url, body: entity)
-              end
-end
-
-When /^(GET|PUT|POST|DELETE) is sent to '([^']*)'$/ do |method, endpoint|
-  start_time = Time.now
-  url = "http://localhost:7001#{endpoint}"
-  @response = case method
-                when 'GET' then
-                  get(url)
-                when 'PUT' then
-                  put(url, body: '')
-                when 'POST' then
-                  post(url, body: '')
-                when 'DELETE' then
-                  delete(url)
-              end
-  @response_time = Time.now - start_time
-end
-
-When /^I click '(.*)'$/ do |thing|
-  @page = @page.links.find { |link| link.attributes['id'] == thing }.click
-end
-
-When /^I send (GET|POST) to '(.*)' with parameters:$/ do |http_method, endpoint, table|
-
-
-  url = "http://localhost:7001#{endpoint}"
-  parameters = {}
-  table.raw.each do |row|
-    parameter, value = row[0].to_sym, row[1]
-    value = File.exists?(value) ? File.open(value, 'rb') : value
-    parameters[parameter]=value
-  end
-
-  @response = case http_method
-                when 'POST' then
-                  post(url, query: parameters, headers: {'Content-length' => '0'})
-                when 'GET' then
-                  get(url, query: parameters)
-              end
-end
-
-Given /^the following template template:$/ do |text|
-  @response_template = Hashie::Mash.new(JSON.parse(text))
-end
-
-When /^'(.*)' is base64 encoded$/ do |template_component|
-  @response_template.send(:eval, "#{template_component}=Base64.encode64(#{template_component})")
-end
-
-When /^the template is sent using PUT to '(.*?)'$/ do |endpoint|
-  @response = put("http://localhost:7001#{endpoint}", body: @response_template.to_hash.to_json, :headers => {"Content-Type" => "application/json"})
-end
-
-Given /^a template for '(.*)' has been set with a value of '(.*)'$/ do |endpoint, value|
-  mirage.templates.put(endpoint, value)
-end
-
-Given(/^the following Template JSON:$/) do |text|
-  @response_template = Hashie::Mash.new(JSON.parse(text))
-end