mirage-on-thin 3.0.8

data/features/step_definitions/my_steps.rb

@@ -0,0 +1,98 @@
+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
+  puts parameters
+
+  @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

data/features/step_definitions/observation_steps.rb

@@ -0,0 +1,103 @@
+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
+  puts @response.body
+  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

@@ -0,0 +1,33 @@
+require 'tempfile'
+module CommandLine
+  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.seconds) { 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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,20 @@
+require 'httparty'
+module Mirage
+  module Web
+    def get *args
+      HTTParty.get(*args)
+    end
+    def put *args
+      HTTParty.put(*args)
+    end
+    def post *args
+      puts "running this one"
+      HTTParty.post(*args)
+    end
+    def delete *args
+      HTTParty.delete(*args)
+    end
+  end
+end
+
+World(Mirage::Web)

data/features/templates/delete.feature

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,18 @@
+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