rack_doubles 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.rvmrc
+Gemfile.lock
+pkg/*
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hubcaps.gemspec
+gemspec

data/README.md

@@ -0,0 +1,90 @@
+# Rack Doubles
+
+Rack Doubles is a simpler clone of [rack-stubs](https://github.com/featurist/rack-stubs) a rack middleware for stubbing reponses to GET requests on HTTP web services
+Rack Doubles uses the HTTP PUT request method to create stubs
+
+## Installation
+
+    gem install rack_doubles
+
+## Rack Doubles middleware
+
+Rack Doubles is implemented as rack middleware, so you would typically host it as part of a rack web app. You can write a rack configuration (`config.ru`) like this if you want to get started:
+
+    require 'rubygems'    
+    require 'rack_doubles'
+
+    use RackDoubles::Middleware
+    run lambda { |e| [404, { 'Content-Type' => 'text/plain' }, ["Not found"]] }
+  
+Then you can run the rackup binary:
+
+    rackup
+
+...and you'll have a server with Rack Doubles running at http://127.0.0.1:9292
+
+You create a stubbed response for a resource by issuing a PUT request to that resource location with a body that represents the tuple of http response you want to receive with a subsequent GET or POST request.   
+For example you want a HTTP GET requests to `/some-service` to return an HTTP `200` status, with the body `"Hello World"` and the `Content-Type:"text/plain"`.   
+Rack requires a `Content-Type` to be set for all responses so failure to include one in the stub request will generate a `400` response    
+Using a HTTP request tool such as [rest-client](https://github.com/archiloque/rest-client) or [httpparty](http://johnnunemaker.com/httparty) you make the following request:
+
+    method  : PUT
+    action  : http://127.0.0.1:9292/some-service
+    body    : [200, { "Content-Type": "text/plain" }, ["Hello World"]]
+    headers : Content-Type=application/json
+
+All subsequent GET requests to http://127.0.0.1:9292/some-service should now return the resonse: 
+
+    HTTP 200 status, 
+    Content-Type=text/plain
+    "Hello World" 
+  
+The body of the PUT request is json, and is implemented as a hash of simple rack-style response tuples.
+
+A list of all stubbed responses can be obtainined as a JSON representation by sending a GET request to '/'.
+
+    put /example, [200, { "Content-Type": "text/plain" }, ["Hello World"]]
+
+then
+   
+    get /
+    
+and the response body is:
+    
+     {'/example: [200, { "Content-Type": "text/plain" }, ["Hello World"]] }
+     
+Individual stub responses can be removed by sending a DELETE request to their resource location, to remove all stubs send a DELETE request to '/'.
+
+## Logging
+
+For basic mocking purposes individual counts for all the requests made to the stub service can be obtained by making a GET request to the url '/log':
+
+    put /example, [200, { "Content-Type": "text/plain" }, ["Hello World"]]
+    
+    get /example
+    get /another-example
+    get /another-example
+
+then
+    
+    get /log 
+
+and the response body is:
+    
+    {"/example": {"200": 1}, "/another-example": {"404": 2}}
+
+## Rack Doubles client
+
+To use Rack Doubles from Ruby without invoking a HTTP PUT request, Rack Doubles includes a small client library. 
+To set up the same stub on a GET request to 'some-service' you would use the Rack Doubles client like this:
+
+    client = RackDoubles::Client.new("http://127.0.0.1:9292")
+    client.stub("/some-service").to_return(200, { "Content-Type" => "text/plain" }, ["Hello World"])
+  
+To delete individual stubs use:
+
+    client.delete some-service
+  
+and to delete all stub responses use:
+
+    client.delete_all

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/config.ru

@@ -0,0 +1,14 @@
+require 'rack_doubles'
+
+root=File.dirname(__FILE__)
+
+map '/' do
+  run lambda { |e| [200, { 'Content-Type' => 'text/plain' }, ["Rack service is up"]] }
+end
+
+map '/rack-doubles' do
+  use RackDoubles::Middleware do
+    map to: '/rack-doubles'
+  end
+  run lambda { |e| [404, { 'Content-Type' => 'text/plain' }, ["404: Rack Doubles Stub Not Found"]] }
+end

data/features/step_definitions/stub_responses_steps.rb

@@ -0,0 +1,44 @@
+Transform /^(\d\d\d)$/ do |number|
+  number.to_i
+end
+
+Given /^all responses have been cleared$/ do
+  RackDoubles::Middleware.responses.clear
+  RackDoubles::Middleware.requests.clear
+end
+
+Given /^a GET request to "([^"]*)" returns "(\d+)" with the body "([^"]*)"$/ do |path, status, body|
+  get path 
+  last_response.body.should == body
+  last_response.status.should == status
+end
+
+When /^I make a PUT request to "([^"]*)" with the body:$/ do |path, body|
+  put path, body, { 'Content-Type' => 'application/json' }
+end
+
+When /^I make a DELETE request to "([^"]*)"$/ do |path|
+  delete path
+end
+
+Then /^the response returns "([^"]*)" with the body:$/ do |status, body|
+  last_response.status.should == status
+  JSON.parse(last_response.body).should == JSON.parse(body)
+end
+
+Then /^the response returns "([^"]*)" with the body "([^"]*)"$/ do |status, body|
+  last_response.status.should == status
+  JSON.parse(last_response.body).should == JSON.parse(body)
+end
+
+Then /^a GET request to "([^"]*)" returns "([^"]*)" with the body:$/ do |path, status, body|
+  get path
+  last_response.status.should == status
+  JSON.parse(last_response.body).should == JSON.parse(body)
+end
+
+Then /^a GET request to "([^"]*)" returns "([^"]*)" with the head:$/ do |path, status, head|
+  get path
+  last_response.status.should == status
+  last_response.header.should include({"Location"=>"http://www.example.com"})
+end

data/features/stub_responses.feature

@@ -0,0 +1,95 @@
+Feature: Stub Responses
+  In order to simulate behaviour of third-party web services
+  As a test for my application
+  I want to simulate http service behaviour
+  
+  Background:
+    Given all responses have been cleared
+    Given a GET request to "/example-service" returns "404" with the body "Not Found"
+    And a GET request to "/another-example-service" returns "404" with the body "Not Found"
+
+  Scenario: Stub a url end point
+    When I make a PUT request to "/example-service" with the body:
+      """
+      [200, { "Content-Type": "text/plain" }, ["results"]]
+      """
+	  Then the response returns "201" with the body:
+      """
+		  { "url": "/example-service", "response": [200, { "Content-Type": "text/plain" }, ["results"]] }
+      """
+    And a GET request to "/example-service" returns "200" with the body "results"
+    And a GET request to "/" returns "200" with the body:
+      """
+      { "/example-service": [200, { "Content-Type": "text/plain" }, ["results"]] } 
+      """
+    And a GET request to "/log" returns "200" with the body:
+      """
+      {"/example-service": {"404": 1, "200": 1}, "/another-example-service": {"404": 1}}
+      """
+      
+  Scenario: Returns 400 if the stub request fails to contain a Content-Type pair
+    When I make a PUT request to "/example-service" with the body:
+      """
+      [200, { }, ["results"]]
+      """
+	  Then the response returns "400" with the body:
+      """
+      {"reason": "Subbing a response requires the body of the PUT request to contain a tuple with the response status and header Content-Type"}
+      """      
+      
+  Scenario: Stub a url end point to 302
+    When I make a PUT request to "/redirect-this-request" with the body:
+      """
+      [302, { "Content-Type": "text/plain", "Location": "http://www.example.com" }, []]
+      """
+	  Then the response returns "201" with the body:
+      """
+		  { "url": "/redirect-this-request", "response": [302, { "Content-Type": "text/plain", "Location": "http://www.example.com" }, []] }
+      """
+    And a GET request to "/redirect-this-request" returns "302" with the head:
+      """
+      { "Content-Type": "text/plain", "Location": "http://www.example.com" }
+      """      
+	
+  Scenario: Clear all stub responses
+   	When I make a PUT request to "/example-service" with the body:
+      """
+      [200, {}, ["Another response"]]
+      """
+    When I make a DELETE request to "/"
+	  Then the response returns "200" with the body "{}"
+    And a GET request to "/" returns "200" with the body "{}"
+    And a GET request to "/example-service" returns "404" with the body "Not Found"
+    And a GET request to "/log" returns "200" with the body:
+      """
+      {"/example-service": {"404": 2}, "/another-example-service": {"404": 1}}
+      """
+ 	
+  Scenario: Clear single stub responses
+   	And I make a PUT request to "/example-service" with the body:
+      """
+      [200, { "Content-Type": "text/plain" }, ["Example response"]]
+      """
+ 	  And I make a PUT request to "/another-example-service" with the body:
+      """
+      [200, { "Content-Type": "text/plain" }, ["Another response"]]
+      """
+    When I make a DELETE request to "/example-service"
+	  Then the response returns "200" with the body:
+      """
+		  {"/another-example-service": [200, { "Content-Type": "text/plain" }, ["Another response"]]}
+      """
+    And a GET request to "/example-service" returns "404" with the body "Not Found"
+    And a GET request to "/" returns "200" with the body:
+      """
+      {"/another-example-service": [200, { "Content-Type": "text/plain" }, ["Another response"]]} 
+      """
+    And a GET request to "/log" returns "200" with the body:
+      """
+      {"/example-service": {"404": 2}, "/another-example-service": {"404": 1}} 
+      """
+  
+  Scenario: Clear the log
+    When I make a DELETE request to "/log"
+	  Then the response returns "200" with the body "{}"
+    Then a GET request to "/log" returns "200" with the body "{}"

data/features/support/env.rb

@@ -0,0 +1,14 @@
+$: << './lib/rack_doubles'
+require 'rack'
+require 'middleware'
+require 'rack/test'
+require 'json'
+
+
+module RackDoubles
+  def app
+    RackDoubles::Middleware.new(lambda{ |env| [404, {}, 'Not Found'] })
+  end 
+end
+
+World(Rack::Test::Methods, RackDoubles)

data/lib/rack_doubles/client.rb

@@ -0,0 +1,43 @@
+require 'rest-client'
+
+module RackDoubles
+  
+  class Client
+    
+    def initialize(service, http_client = RestClient) 
+      @service = service
+      @http_client = http_client
+    end
+    
+    def stub resource
+      @stub = Stub.new url_for(resource), @http_client
+    end
+    
+    def delete resource
+      @http_client.delete url_for(resource)
+    end
+    
+    def delete_all
+      @http_client.delete url_for('/')
+    end
+    
+    def url_for path
+      @service.gsub(/\/+$/, '') + '/' + path.gsub(/^\/+/, '')
+    end
+    
+  end
+  
+  class Stub
+    
+    def initialize url, http_client
+      @url = url
+      @http_client = http_client
+    end
+    
+    def to_return status, headers, body
+      @http_client.put(@url, [200, headers, [body]].to_json, { 'Content-Type' => 'application/json' })
+    end
+    
+  end
+  
+end

data/lib/rack_doubles/middleware.rb

@@ -0,0 +1,100 @@
+require 'json'
+
+module RackDoubles
+  
+  class Middleware  
+    
+    @responses = {}
+    @requests = Hash.new { |hash, key| hash[key] = Hash.new(0) }
+
+    class << self; attr_accessor :responses, :requests, :errors; end
+    
+    def responses
+      self.class.responses
+    end
+    
+    def requests
+      self.class.requests
+    end
+    
+    def errors
+      self.class.errors
+    end
+  
+    def initialize(app, &block)
+      @app = app
+      @path = '/'
+      yield self if block_given?
+    end
+    
+    attr_accessor :path
+    
+    def call(env)
+      request = Rack::Request.new(env)
+      if request.get?
+         case request.path
+         when /#{path}\/?$/
+           [200, {"Content-Type" => "application/json"}, [responses.to_json]]
+         when /log\/?$/
+           [200, {"Content-Type" => "application/json"}, [requests.to_json]]
+         else
+           begin 
+              response = responses.fetch(request.path)
+              record_success request.path
+              response
+           rescue KeyError  
+             record_error request.path
+             @app.call(env)
+           end
+         end
+      elsif request.delete?
+        case request.path
+        when path  
+          responses.clear
+          [200, {"Content-Type" => "application/json"}, [responses.to_json]]
+        when /\/log/
+          requests.clear
+          [200, {"Content-Type" => "application/json"}, [requests.to_json]]
+        else
+          responses.delete request.path
+          [200, {"Content-Type" => "application/json"}, [responses.to_json]]
+        end
+      elsif request.put?
+        body_of_request = JSON.parse(request.body.read.to_s)
+        status, headers, body = body_of_request
+        begin
+          raise ArgumentError if [status, headers].any?(&:nil?) || headers['Content-Type'].nil?
+          responses.merge!({request.path => body_of_request})
+          [201, { 'Content-Type' => 'application/json' }, [%|{ "url": "#{request.path}", "response": #{responses.fetch(request.path).to_json} }|]]
+        rescue ArgumentError
+          [400, { 'Content-Type' => 'application/json' }, [%|{ "reason": "Subbing a response requires the body of the PUT request to contain a tuple with the response status and header Content-Type" }|]]
+        end
+      end
+    end
+    
+    def stub path
+      Response.new(responses, path)
+    end
+  
+    def record_success request_url
+      requests[request_url]['200'] += 1
+    end
+    
+    def record_error request_url
+      requests[request_url]['404'] += 1
+    end
+    
+    class Response
+    
+      def initialize(responses, path)
+        @responses, @path = responses, path
+      end
+    
+      def to_return(status, headers, body)
+        @responses[@path] = [status, headers, body]
+      end
+    
+    end
+
+  end
+end

data/lib/rack_doubles/version.rb

@@ -0,0 +1,3 @@
+module RackDoubles  
+  VERSION = "0.0.1"
+end

data/lib/rack_doubles.rb

@@ -0,0 +1,11 @@
+require "rack_doubles/version"
+require 'rack_doubles/middleware'
+require 'rack_doubles/client'
+
+
+module RackDoubles
+  # Your code goes here...
+end
+
+
+

data/rack_doubles.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack_doubles/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "rack_doubles"
+  spec.version     = RackDoubles::VERSION
+  spec.author      = "Anthony Green"
+  spec.email       = "anthony.green@bbc.co.uk"
+  spec.homepage    = "https://github.com/anthonygreen/rack_doubles"
+  spec.summary     = "Rack middleware for stubbing responses from HTTP web services"
+  spec.description = "Rack middleware for creating faking responses for HTTP web services that an application under test communicates with"
+
+  spec.rubyforge_project = "rack_doubles"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.required_ruby_version = '>= 1.9.3'
+  
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'cucumber'
+  spec.add_development_dependency 'rack-test'
+  spec.add_development_dependency 'rest-client'
+  
+  spec.add_runtime_dependency 'json'
+  spec.add_runtime_dependency 'rack'
+  spec.add_runtime_dependency 'rest-client'
+  
+end

data/spec/rack_doubles/client_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'json'
+
+module RackDoubles  
+  
+  describe Client do
+    
+    def http_client_should_stub(url, response)
+      @http_client.should_receive(:put).with(url, response, {'Content-Type' => 'application/json'})
+    end
+
+    before do
+      @http_client = mock("http_client")
+      @client = Client.new("http://path-to-service", @http_client)
+    end
+
+    it "stubs url end points" do
+      http_client_should_stub("http://path-to-service/resource", [200, {}, ["This should be the response body"]].to_json)
+      @client.stub("/resource").to_return(200, {}, "This should be the response body")
+    end
+    
+    it "deletes a stub" do
+      @http_client.should_receive(:delete).with("http://path-to-service/some-resource") 
+      @client.delete 'some-resource'
+    end
+    
+    it "deletes all stubs" do
+      @http_client.should_receive(:delete).with("http://path-to-service/") 
+      @client.delete_all
+    end
+    
+    
+  end
+end

data/spec/rack_doubles/middleware_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module RackDoubles
+    
+  describe Middleware do
+
+    it "allows stub behaviour to be specified using the client interface" do
+      app = mock('app')
+      env = Rack::MockRequest.env_for('/some-service')
+      middleware = Middleware.new(app)
+      middleware.stub('/some-service').to_return(200, {}, 'Successful')
+      middleware.call(env).should == [200, {}, 'Successful']
+    end
+
+    it "deletes all stubbed responses" do
+      app = mock('app')
+      middleware = Middleware.new(app)
+      middleware.stub('/service').to_return(200, {}, 'Success')
+      middleware.stub('/another_service').to_return(200, {}, 'OK')
+      middleware.responses.clear
+      get_env = Rack::MockRequest.env_for('/service')
+      get_env2 = Rack::MockRequest.env_for('/another_service')
+      app.should_receive('call').with(get_env)
+      app.should_receive('call').with(get_env2)
+      middleware.call(get_env)
+      middleware.call(get_env2)
+    end
+
+    it "deletes a single stubbed response" do
+      app = mock('app')
+      middleware = Middleware.new(app)
+      middleware.stub('/service').to_return(200, {}, 'Success')
+      middleware.stub('/another-service').to_return(200, {}, 'OK')
+      middleware.responses.delete('/service')
+      middleware.responses.delete('/service-that-does-not-exist')
+      get_env = Rack::MockRequest.env_for('/service')
+      get_env2 = Rack::MockRequest.env_for('/another-service')
+      app.should_receive('call').with(get_env)
+      app.should_not_receive('call').with(get_env2)
+      middleware.call(get_env)
+      middleware.call(get_env2)
+    end
+    
+    it "can map to a base path" do
+      app = mock('app')
+      env = Rack::MockRequest.env_for('/rack-doubles')
+      middleware = Middleware.new(app) do |app|
+        app.path = '/rack-doubles'
+      end
+      middleware.stub('/rack-doubles/some-service').to_return(200, {}, 'Successful')
+      middleware.call(env).should == [200, { "Content-Type"=>"application/json" }, [%|{"/another-service":[200,{},"OK"],"/rack-doubles/some-service":[200,{},"Successful"]}|]]
+    end
+    
+  
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rack'
+require 'rack_doubles/middleware'
+require 'rack_doubles/client'

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: rack_doubles
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Anthony Green
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rack middleware for creating faking responses for HTTP web services that
+  an application under test communicates with
+email: anthony.green@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- config.ru
+- features/step_definitions/stub_responses_steps.rb
+- features/stub_responses.feature
+- features/support/env.rb
+- lib/rack_doubles.rb
+- lib/rack_doubles/client.rb
+- lib/rack_doubles/middleware.rb
+- lib/rack_doubles/version.rb
+- rack_doubles.gemspec
+- spec/rack_doubles/client_spec.rb
+- spec/rack_doubles/middleware_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/anthonygreen/rack_doubles
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rack_doubles
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rack middleware for stubbing responses from HTTP web services
+test_files:
+- features/step_definitions/stub_responses_steps.rb
+- features/stub_responses.feature
+- features/support/env.rb
+- spec/rack_doubles/client_spec.rb
+- spec/rack_doubles/middleware_spec.rb
+- spec/spec_helper.rb