spoofer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 239d4797905c9be787b45a1d3801723da8c247ab
+  data.tar.gz: 2eec7230cc9429933ff77bc2571a1e882a9009bb
+SHA512:
+  metadata.gz: eaec9fd7a0e78ff537c890d069b06e06e235098f4762c1e918c1a794d410583f854afe896496bf6eab0f75bf21bc950dcc4c68e1bbfbe286812217d338ee985e
+  data.tar.gz: 2861633a8005d55d0cebec20c422502244c830ac9e442abed7221ac3f104c16f3e672eb346af10194da82c0fa2a9b4d65d426d2882f21540b3fb502a2fd13b3e

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Justin Smestad
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Spoofer, simple web service stubs for testing [![Build Status](https://secure.travis-ci.org/jsmestad/spoofer.png)](https://secure.travis-ci.org/jsmestad/spoofer)
+
+
+## What is Spoofer?
+
+Spoofer is a fork of the [Mimic Ruby Gem]() project. It was not being actively maintained anymore and decided to create a new fork using Mimic as a basis.
+
+If your unfamiliar with the Mimic gem, then... Spoofer is a testing tool that lets you set create a fake stand-in for an external web service to be used when writing integration/end-to-end tests for applications or libraries that access these services.
+
+## Why not stub?
+There are already some good tools, like [FakeWeb](http://fakeweb.rubyforge.org/) which let you stub requests at a low-level which is fine for unit and functional tests but when exercising our code through integration or end-to-end tests we want to exercise as much of the stack as possible.
+
+Spoofer aims to make it possible to test your networking code without actually hitting the real services by starting up a real web server and responding to HTTP requests. This lets you test your application against canned responses in an as-close-to-the-real-thing-as-possible way.
+
+Also, because Spoofer responds to real HTTP requests, it can be used when testing non-Ruby applications too.
+
+## Examples
+
+Registering to a single request stub:
+
+    Spoofer.mimic.get("/some/path").returning("hello world")
+
+And the result, using RestClient:
+
+    $ RestClient.get("http://www.example.com:11988/some/path") # => 200 | hello world
+
+Registering multiple request stubs; note that you can stub the same path with different HTTP methods separately.
+
+    Spoofer.mimic do
+      get("/some/path").returning("Hello World", 200)
+      get("/some/other/path").returning("Redirecting...", 301, {"Location" => "somewhere else"})
+      post("/some/path").returning("Created!", 201)
+    end
+
+You can even use Rack middlewares, e.g. to handle common testing scenarios such as authentication:
+
+    Spoofer.mimic do
+      use Rack::Auth::Basic do |user, pass|
+        user == 'theuser' and pass == 'thepass'
+      end
+
+      get("/some/path")
+    end
+
+Finally, because Spoofer is built on top of Sinatra for the core request handling, you can create your stubbed requests like you would in any Sinatra app:
+
+    Spoofer.mimic do
+      get "/some/path" do
+        [200, {}, "hello world"]
+      end
+    end
+
+## Using Spoofer with non-Ruby processes
+
+Spoofer has a built-in REST API that lets you configure your request stubs over HTTP. This makes it possible to use Spoofer from other processes that can perform HTTP requests.
+
+First of all, you'll need to run Spoofer as a daemon. You can do this with a simple Ruby script and the [daemons](http://daemons.rubyforge.org/) gem:
+
+    #!/usr/bin/env ruby
+    require 'spoofer'
+    require 'daemons'
+
+    Daemons.run_proc("mimic") do
+      Spoofer.mimic(:port => 11988, :fork => false, :remote_configuration_path => '/api') do
+        # configure your stubs here
+      end
+    end
+
+Give the script executable permissions and then start it:
+
+    $ your_spoofer_script.rb start (or run)
+
+The remote configuration path is where the API endpoints will be mounted - this is configurable as you will not be able this path or any paths below it in your stubs, so choose one that doesn't conflict with the paths you need to stub.
+
+The API supports both JSON and Plist payloads, defaulting to JSON. Set the request Content-Type header to application/plist for Plist requests.
+
+For the following Spoofer configuration (using the Ruby DSL):
+
+    Spoofer.mimic.get("/some/path").returning("hello world")
+
+The equivalent stub can be configured using the REST API as follows:
+
+    $ curl -d'{"path":"/some/path", "body":"hello world"}' http://localhost:11988/api/get
+
+Likewise, a POST request to the same path could be stubbed like so:
+
+    $ curl -d'{"path":"/some/path", "body":"hello world"}' http://localhost:11988/api/post
+
+The end-point of the API is the HTTP verb you are stubbing, the path, response body, code and headers are specified in the POST data (a hash in JSON or Plist format). See the HTTP API Cucumber features for more examples.
+
+## License
+
+See LICENSE file distributed with this gem.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'cucumber'
+require 'cucumber/rake/task'
+
+ENV["POSER_TEST_PROXY"] = nil
+
+desc "Run all Cucumber features"
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+task :all => [:spec, :features]
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']   # optional
+  t.options = ['--any', '--extra', '--opts'] # optional
+end

data/features/checking_requests_were_made.feature

@@ -0,0 +1,39 @@
+Feature: Checking requests were made
+  In order to verify requests were made to mimic (like mock expectations)
+  As a developer
+  I want to be able to ask the Spoofer API what requests were made
+  
+  Scenario: Configuring a request and verifying it was called
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response with a body containing:
+      """
+      {"stubs":["41f660b868e1308e8d87afbb84532b71"]}
+      """
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    And I make an HTTP GET request to "http://localhost:11988/api/requests"
+    Then I should receive an HTTP 200 response with a body containing:
+      """
+      {"requests":["41f660b868e1308e8d87afbb84532b71"]}
+      """
+
+  Scenario: Configuring a request and verifying it was not called
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response with a body containing:
+      """
+      {"stubs":["41f660b868e1308e8d87afbb84532b71"]}
+      """
+    And I make an HTTP GET request to "http://localhost:11988/api/requests"
+    Then I should receive an HTTP 200 response with a body containing:
+      """
+      {"requests":[]}
+      """
+    
+    

data/features/configuring_spoofer_via_http.feature

@@ -0,0 +1,175 @@
+Feature: Configuring Spoofer via an HTTP interface
+  In order to use Spoofer stubs from non-Ruby test cases
+  As a developer
+  I want to be able to configure a background Spoofer process using an HTTP REST API
+  
+  Scenario: Pinging Spoofer via the API to check it's running
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP GET request to "http://localhost:11988/api/ping"
+    Then I should receive an HTTP 200 response with a body matching "OK"
+    
+  Scenario: Stubbing a request path via GET using the HTTP API
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a request path via POST the HTTP API
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/post" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP POST request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+  
+  Scenario: Stubbing a request path via PUT using the HTTP API
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/put" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP PUT request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+
+  Scenario: Stubbing a request path via DELETE the HTTP API for a
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/delete" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP DELETE request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Stubbing a request path via HEAD using the HTTP API
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/head" with the payload:
+      """
+        {"path": "/anything"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP HEAD request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+
+  Scenario: Stubbing a request path to return a custom response body
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "body": "Hello World"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with a body matching "Hello World"
+    
+  Scenario: Stubbing a request path to return a custom status code
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "code": 301}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 301 response with an empty body
+    
+  Scenario: Stubbing a request path to return custom headers
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "headers": {"X-TEST-HEADER": "TESTING"}}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with the value "TESTING" for the header "X-TEST-HEADER"
+    
+  Scenario: Stubbing a request path that only matches with the right query params
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "params": {"foo": "bar"}}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 404 response
+    And I make an HTTP GET request to "http://localhost:11988/anything?foo=bar"
+    Then I should receive an HTTP 200 response
+    
+  Scenario: Stubbing a request to echo it's request 
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "echo": "json"}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything?foo=bar"
+    Then I should receive an HTTP 200 response with the JSON value "bar" for the key path "echo.params.foo"
+    
+  Scenario: Stubbing a request using the HTTP API in plist format
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request with a "application/plist" content-type to "http://localhost:11988/api/get" and the payload:
+      """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+          <key>path</key>
+          <string>/anything</string>
+        </dict>
+        </plist>
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Configuring multiple stubs for a single verb in a single request
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"stubs":[{"path": "/anything"}, {"path": "/something"}]}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+    And I make an HTTP GET request to "http://localhost:11988/something"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Configuring multiple stubs for different verbs in a single request
+    Given that Spoofer is running and accepting remote configuration on "/api"
+    When I make an HTTP POST request to "http://localhost:11988/api/multi" with the payload:
+      """
+        {"stubs":[{"method": "GET", "path": "/anything"}, {"method": "POST", "path": "/something"}]}
+      """
+    Then I should receive an HTTP 201 response
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with an empty body
+    And I make an HTTP POST request to "http://localhost:11988/something"
+    Then I should receive an HTTP 200 response with an empty body
+    
+  Scenario: Clearing all stubs via the HTTP API
+    Given that Spoofer is running and accepting remote configuration on "/api" with the existing stubs:
+      """
+        get("/anything").returning("hello world")
+      """
+    When I make an HTTP POST request to "http://localhost:11988/api/clear"
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 404 response with an empty body
+
+  Scenario: Clearing all stubs then resetting a stub via the API
+    Given that Spoofer is running and accepting remote configuration on "/api" with the existing stubs:
+      """
+        get("/anything").returning("hello world")
+      """
+    When I make an HTTP POST request to "http://localhost:11988/api/clear"
+    When I make an HTTP POST request to "http://localhost:11988/api/get" with the payload:
+      """
+        {"path": "/anything", "body": "something else"}
+      """
+    And I make an HTTP GET request to "http://localhost:11988/anything"
+    Then I should receive an HTTP 200 response with a body matching "something else"
+    

data/features/echoing_request_in_response.feature

@@ -0,0 +1,76 @@
+Feature: Echoing request in response
+  In order to easily verify that I sent the correct request data
+  As a developer
+  I want to tell mimic to echo the request data in a specific format in it's response
+  
+  Scenario: Echoing query parameters in JSON format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").echo_request!(:json)
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with the JSON value "bar" for the key path "echo.params.foo"
+    
+  Scenario: Echoing request headers in JSON format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").echo_request!(:json)
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path" with the header "X-TEST: Some Value"
+    Then I should receive an HTTP 200 response with the JSON value "Some Value" for the key path "echo.env.HTTP_X_TEST"
+    
+  Scenario: Echoing request body in JSON format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).post("/some/path").echo_request!(:json)
+      """
+    When I make an HTTP POST request to "http://localhost:11988/some/path" with the payload:
+      """
+      REQUEST BODY
+      """
+    Then I should receive an HTTP 200 response with the JSON value "REQUEST BODY" for the key path "echo.body"
+
+  Scenario: Echoing query parameters in Plist format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").echo_request!(:plist)
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with the Plist value "bar" for the key path "echo.params.foo"
+
+  Scenario: Echoing request headers in Plist format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").echo_request!(:plist)
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path" with the header "X-TEST: Some Value"
+    Then I should receive an HTTP 200 response with the Plist value "Some Value" for the key path "echo.env.HTTP_X_TEST"
+
+  Scenario: Echoing request body in Plist format
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).post("/some/path").echo_request!(:plist)
+      """
+    When I make an HTTP POST request to "http://localhost:11988/some/path" with the payload:
+      """
+      REQUEST BODY
+      """
+    Then I should receive an HTTP 200 response with the Plist value "REQUEST BODY" for the key path "echo.body"
+    
+  Scenario: Echoing query parameters but also specifying a response body results in response body being overwritten
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path").returning("not an echo").echo_request!(:json)
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with the JSON value "bar" for the key path "echo.params.foo"
+    
+  Scenario: Echoing response manually from block definition
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988).get("/some/path") do
+        echo_request!(:json)
+      end
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path?foo=bar"
+    Then I should receive an HTTP 200 response with the JSON value "bar" for the key path "echo.params.foo"

data/features/logging_requests.feature

@@ -0,0 +1,13 @@
+Feature: Logging incoming requests
+  In order to check that Spoofer is working properly or provide further debug information
+  As a developer
+  I want to be able to tell Spoofer to log incoming requests
+  
+  Scenario: Logging to STDOUT
+    Given I have a spoofer specification with:
+      """
+      Spoofer.mimic(:port => 11988, :log => $stdout).get("/some/path")
+      """
+    When I make an HTTP GET request to "http://localhost:11988/some/path"
+    Then I should see "GET /some/path HTTP/1.1" written to STDOUT
+