spoofer 0.1.0

data/features/resetting_stubs.feature

@@ -0,0 +1,16 @@
+Feature: Resetting stubs
+  In order to create a deterministic clean slate at the beginning of my specs
+  As a developer
+  I want to be able to reset all previously configured request stubs
+
+  Scenario: Clearing a stubbed request
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").returning("Hello World", 201)
+      """
+    When I evaluate the code:
+      """
+      Spoofer.reset_all!
+      """
+    And I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 404 response with an empty body

data/features/steps/http_client_steps.rb

@@ -0,0 +1,60 @@
+Before do
+  @httpclient = HttpClient.new
+end
+
+def headers_from_string(string)
+  string.split("\n").inject({}) do |headers, header_string|
+    headers.tap do |h|
+      components = header_string.split(":")
+      h[components[0].strip] = components[1].strip
+    end
+  end
+end
+
+When /^I make an HTTP (POST|PUT) request to "([^\"]*)" with the payload:$/ do |http_method, url, payload|
+  @httpclient.perform_request_with_payload(url, http_method, payload)
+end
+
+When /^I make an HTTP (POST|PUT) request with a "([^\"]*)" content-type to "([^\"]*)" and the payload:$/ do |http_method, content_type, url, payload|
+  @httpclient.perform_request_with_payload(url, http_method, payload, :content_type => content_type)
+end
+
+When /^I make an HTTP (GET|POST|PUT|DELETE|HEAD) request to "([^\"]*)"$/ do |http_method, url|
+  @httpclient.perform_request(url, http_method)
+end
+
+When /^I make an HTTP (GET|POST|PUT|DELETE|HEAD) request to "([^\"]*)" with the header "([^\"]*)"$/ do |http_method, url, header|
+  @httpclient.perform_request(url, http_method, nil, headers_from_string(header))
+end
+
+Then /^I should receive an HTTP (\d+) response with an empty body$/ do |status_code|
+  steps %Q{
+    Then I should receive an HTTP #{status_code} response with a body matching ""
+  }
+end
+
+Then /^I should receive an HTTP (\d+) response with a body matching "([^\"]*)"$/ do |status_code, http_body|
+  @httpclient.should have_response_with_code_and_body(status_code.to_i, http_body)
+end
+
+Then /^I should receive an HTTP (\d+) response with a body containing:$/ do |status_code, http_body|
+  @httpclient.should have_response_with_code_and_body(status_code.to_i, http_body)
+end
+
+Then /^I should receive an HTTP (\d+) response$/ do |status_code|
+  @httpclient.should have_response_with_code(status_code.to_i)
+end
+
+Then /^I should receive an HTTP (\d+) response with the value "([^\"]*)" for the header "([^\"]*)"$/ do |status_code, header_value, header_key|
+  @httpclient.should have_response_with_code_and_header(status_code.to_i, header_key, header_value)
+end
+
+Then /^I should receive an HTTP (\d+) response with the JSON value "([^\"]*)" for the key path "([^\"]*)"$/ do |status, json_value, key_path|
+  json = JSON.parse(@httpclient.last_response.to_s)
+  json.value_for_key_path(key_path).should == json_value
+end
+
+Then /^I should receive an HTTP (\d+) response with the Plist value "([^\"]*)" for the key path "([^\"]*)"$/ do |status, json_value, key_path|
+  plist = Plist.parse_xml(@httpclient.last_response.to_s)
+  plist.value_for_key_path(key_path).should == json_value
+end

data/features/steps/logging_steps.rb

@@ -0,0 +1,3 @@
+Then /^I should see "([^"]*)" written to STDOUT$/ do |output|
+  TEST_STDOUT.tap { |io| io.rewind }.read.should include(output)
+end

data/features/steps/shell_steps.rb

@@ -0,0 +1,10 @@
+TEMP_FILES = []
+
+Given /^the file "([^\"]*)" exists with the contents:$/ do |file_path, string|
+  File.open(file_path, "w") { |io| io.write(string) }
+  TEMP_FILES << file_path
+end
+
+After do
+  TEMP_FILES.each { |path| FileUtils.rm(path) if File.exist?(path) }
+end

data/features/steps/spoofer_steps.rb

@@ -0,0 +1,21 @@
+Given /^I have a spoofer specification with:$/ do |string|
+  SpooferRunner.new.evaluate(string)
+end
+
+Given /^that Spoofer is running and accepting remote configuration on "([^\"]*)"$/ do |api_endpoint|
+  Spoofer.mimic(:port => 11988, :remote_configuration_path => api_endpoint)
+end
+
+Given /^that Spoofer is running and accepting remote configuration on "([^\"]*)" with the existing stubs:$/ do |api_endpoint, existing_stubs|
+  Spoofer.mimic(:port => 11988, :remote_configuration_path => api_endpoint) do
+    eval(existing_stubs)
+  end
+end
+
+When /^I evaluate the code:$/ do |string|
+  eval(string)
+end
+
+After do
+  Spoofer.cleanup!
+end

data/features/stubbing_requests_by_method.feature

@@ -0,0 +1,25 @@
+Feature: Stubbing requests by path
+  In order to test a range of API endpoints and HTTP verbs
+  As a developer
+  I want to be able to stub requests to return specific responses depending on the request method
+  
+  Scenario: Stubbing a POST request to return a 201 response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).post("/some/path").returning("Hello World", 201)
+      """
+    When I make an HTTP POST request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 201 response with a body matching "Hello World"
+
+  Scenario: Stubbing the same path with different responses for GET and POST
+    Given I have a spoofer specification with:
+      """
+        Spoofer.mimic(:port => 11988) do
+          get("/some/path").returning("Some Record", 200)
+          post("/some/path").returning("Created", 201)
+        end
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with a body matching "Some Record"
+    When I make an HTTP POST request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 201 response with a body matching "Created"

data/features/stubbing_requests_by_path.feature

@@ -0,0 +1,60 @@
+Feature: Stubbing requests by path
+  In order to test my app through its entire stack without depending on an external API
+  As a developer
+  I want to be able to stub requests to specific paths to return a canned response
+  
+  Scenario: Stubbing a GET request to /some/path and return an empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a GET request to /some/path and returning a non-empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").returning("Hello World")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with a body matching "Hello World"
+    
+  Scenario: Requesting an un-stubbed path and getting a 404 response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/other/path"
+    Then I should receive an HTTP 404 response with an empty body
+    
+  Scenario: Stubbing a POST request to /some/path and return an empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).post("/some/path")
+      """
+    When I make an HTTP POST request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a PUT request to /some/path and return an empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).put("/some/path")
+      """
+    When I make an HTTP PUT request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a DELETE request to /some/path and return an empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).delete("/some/path")
+      """
+    When I make an HTTP DELETE request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a HEAD request to /some/path and return an empty response
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).head("/some/path")
+      """
+    When I make an HTTP HEAD request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 200 response with an empty body

data/features/stubbing_requests_from_a_file.feature

@@ -0,0 +1,33 @@
+Feature: Stubbing requests from a file
+  In order to pre-load Spoofer with a set of stubs
+  As a developer
+  I want to be able to store my stub configuration in a separate file and load it in at runtime
+  
+  Scenario: Stubbing requests using a file
+    Given the file "/tmp/test.spoof" exists with the contents:
+      """
+      get("/ping") { "pong" }
+      """
+    And I have a spoofer specification with:
+      """
+        Spoofer.mimic(:port => 11988) do
+          import "/tmp/test.mimic"
+        end
+      """
+    When I make an HTTP GET request to "http://localhost:11988/ping"
+    Then I should receive an HTTP 200 response with a body matching "pong"
+  
+  Scenario: Stubbed requests from a file persist even when Spoofer is cleared
+    Given the file "/tmp/test.spoof" exists with the contents:
+      """
+      get("/ping") { "pong" }
+      """
+    And I have a spoofer specification with:
+      """
+        Spoofer.mimic(:port => 11988) do
+          import "/tmp/test.mimic"
+        end
+        Spoofer.reset_all!
+      """
+    When I make an HTTP GET request to "http://localhost:11988/ping"
+    Then I should receive an HTTP 200 response with a body matching "pong"

data/features/stubbing_requests_with_parameters.feature

@@ -0,0 +1,28 @@
+Feature: Stubbing requests by path
+  In order to test requests that use specific query parameters
+  As a developer
+  I want to be able to only stub requests that have the correct parameters 
+  
+  Scenario: Accepting any parameters to a stubbed path
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Accepting specific parameters and matching
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").with_query_parameters("foo" => "bar")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with an empty body
+  
+  Scenario: Accepting specific parameters and matching
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").with_query_parameters("foo" => "bar")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=baz"
+    Then I should receive an HTTP 404 response

data/features/support/env.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), *%w[.. .. lib]))
+
+TEST_STDOUT = StringIO.new
+
+Before do
+  if test_proxy = ENV["MIMIC_TEST_PROXY"]
+    HttpClient.use_proxy(test_proxy)
+  end
+  
+  $stdout = TEST_STDOUT
+end
+
+After do
+  $stdout = STDOUT
+end

data/features/support/hash_key_path.rb

@@ -0,0 +1,7 @@
+class Hash
+  def value_for_key_path(key_path_string)
+    key_path_string.split(".").inject(self) do |result, key|
+      result[key]
+    end
+  end
+end

data/features/support/http_client.rb

@@ -0,0 +1,50 @@
+require 'rest_client'
+
+class HttpClient
+  attr_reader :last_response
+
+  def self.use_proxy(proxy)
+    RestClient.proxy = proxy
+  end
+
+  def initialize
+    @last_response = nil
+  end
+
+  def perform_request(url, method, payload = nil, options={})
+    RestClient.send(method.downcase, url, options) do |response, request|
+      @last_response = response
+    end
+  end
+
+  def perform_request_with_payload(url, method, payload, options={})
+    RestClient.send(method.downcase, url, payload, options) do |response, request|
+      @last_response = response
+    end
+  end
+
+  def has_response_with_code_and_body?(status_code, response_body)
+    if @last_response
+      return @last_response.code.to_i == status_code && @last_response.to_s == response_body
+    end
+  end
+
+  def has_response_with_code?(status_code)
+    if @last_response
+      @last_response.code.to_i == status_code
+    end
+  end
+
+  def has_response_with_code_and_header?(status_code, header_key, header_value)
+    if @last_response
+      @last_response.code.to_i == status_code &&
+      @last_response.headers[beautify_header(header_key)] == header_value
+    end
+  end
+
+private
+
+  def beautify_header(header_key)
+    header_key.downcase.gsub(/-/, '_').to_sym
+  end
+end

data/features/support/spoofer_runner.rb

@@ -0,0 +1,7 @@
+require 'spoofer'
+
+class SpooferRunner
+  def evaluate(code_string)
+    instance_eval(code_string)
+  end
+end

data/features/using_rack_middlewares.feature

@@ -0,0 +1,31 @@
+Feature: Injecting Rack middleware into the request chain for a stub
+  In order to test common scenarios (e.g. authentication)
+  As a developer
+  I want to be able to use Rack middlewares for certain responses
+  
+  Scenario: Using Rack::Auth to simulate failed authentication
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988) do
+        use Rack::Auth::Basic do |username, password|
+        end
+        
+        get("/some/path")
+      end
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should receive an HTTP 401 response
+    
+  Scenario: Using Rack::Auth to simulate successful authentication
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988) do
+        use Rack::Auth::Basic do |username, password|
+          username == 'test' && password == 'pass'
+        end
+
+        get("/some/path")
+      end
+      """
+    When I make an HTTP GET request to "http://test:pass@localhost:11988/some/path"
+    Then I should receive an HTTP 200 response

data/lib/spoofer.rb

@@ -0,0 +1,104 @@
+require 'singleton'
+require 'rack'
+require 'logger'
+require 'json'
+require 'plist'
+require 'socket'
+require 'digest'
+require 'sinatra'
+
+module Spoofer
+  autoload :API, 'spoofer/api'
+  autoload :FakeHost, 'spoofer/fake_host'
+
+  SPOOFER_DEFAULT_PORT = 11988
+
+  SPOOFER_DEFAULT_OPTIONS = {
+    hostname: 'localhost',
+    port: SPOOFER_DEFAULT_PORT,
+    remote_configuration_path: nil,
+    fork: true,
+    log: nil
+  }
+
+  def self.poser(options = {}, &block)
+    options = SPOOFER_DEFAULT_OPTIONS.merge(options)
+
+    host = FakeHost.new(options).tap do |h|
+             h.instance_eval(&block) if block_given?
+             Server.instance.serve(h, options)
+           end
+    add_host(host)
+  end
+
+  def self.cleanup!
+    Spoofer::Server.instance.shutdown
+  end
+
+  def self.reset_all!
+    @hosts.each { |h| h.clear }
+  end
+
+private
+
+  def self.add_host(host)
+    host.tap { |h| (@hosts ||= []) << h }
+  end
+
+  class Server
+    include Singleton
+
+    def logger
+      @logger ||= Logger.new(StringIO.new)
+    end
+
+    def serve(app, options)
+      if options[:fork]
+        @thread = Thread.fork do
+          start_service(app, options)
+        end
+
+        wait_for_service(app.hostname, options[:port])
+
+      else
+        start_service(app, options)
+      end
+    end
+
+    def start_service(app, options)
+      Rack::Handler::Thin.run(app.url_map, {
+        :Port       => options[:port],
+        :Logger     => logger,
+        :AccessLog  => logger,
+      })
+    end
+
+    def shutdown
+      Thread.kill(@thread) if @thread
+    end
+
+    # courtesy of http://is.gd/eoYho
+
+    def listening?(host, port)
+      begin
+        socket = TCPSocket.new(host, port)
+        socket.close unless socket.nil?
+        true
+      rescue Errno::ECONNREFUSED, SocketError,
+        Errno::EBADF,           # Windows
+        Errno::EADDRNOTAVAIL    # Windows
+        false
+      end
+    end
+
+    def wait_for_service(host, port, timeout = 5)
+      start_time = Time.now
+
+      until listening?(host, port)
+        if timeout && (Time.now > (start_time + timeout))
+          raise SocketError.new("Socket did not open within #{timeout} seconds")
+        end
+      end
+    end
+  end
+end