redrock 0.1.0

data/README.rdoc

@@ -0,0 +1,88 @@
+= RedRock
+
+== What is this?
+
+A wrapper for running WebMock[link:http://github.com/bblimke/webmock] remotely
+(ie mocking requests made by an application that's not running in the same
+process as your tests).
+
+== When might I want to use it?
+
+If you're testing an application that makes remote web requests, and for some
+reason you can't run the application code directly inside your test framework.
+This might be because you're running integration tests against a stack of
+applications, you're using something like
+Culerity[link:http://github.com/langalex/culerity] or
+Selenium[link:http://seleniumhq.org/], or maybe the application doesn't use one
+of the HTTP libraries that WebMock supports, or isn't even written in Ruby.
+
+== Getting started
+
+  gem install redrock
+
+Somewhere in your tests:
+
+  require "redrock"
+  include RedRock
+
+You can then make most of the same calls you would normally make to WebMock,
+and they will be transparently handled by RedRock. For example:
+
+  stub_request :any, "localhost:4242/chunky/bacon"
+  # ...
+  RedRock.should have_requested :get, "http://localhost:4242/chunky/bacon"
+
+The RedRock server starts automatically when required, but you can start it
+manually if you want to run it on a different port:
+
+  RedRock.start 1234
+
+You can also stop it manually:
+
+  RedRock.stop
+
+If you want to use a host other than localhost, you can map it in
+<tt>/etc/hosts</tt>. If you can't override the port your application talks to,
+you'll have to set up a reverse proxy as well.
+
+== How does it work?
+
+RedRock fires up a thin[link:http://code.macournoyer.com/thin/] server (by
+default on port 4242), which attempts to proxy all incoming requests using
+Net::HTTP, at which point they are intercepted by WebMock. You point your
+application under test at this server, instead of the real service it's
+supposed to interact with.
+
+All calls to WebMock methods in your tests are proxied through to the RedRock
+server, which means that stubs and expectations are effectively being applied
+to the requests being made by the application under test.
+
+=== Unsupported WebMock features
+
+Allowing real requests doesn't really make any sense for RedRock, so if you
+call <tt>allow_net_connect!</tt> or <tt>disable_net_connect!</tt> you'll get an
+error.
+
+Raising exceptions or timing out won't work as expected, because the exceptions
+will be handled in the RedRock server, not the application under test.
+
+== TODO
+
+* Better documentation!
+* Refactor the server, which is currently a small ball of mud.
+
+== Why "RedRock"?
+
+I started with "Remote WebMock". "RWebMock" doesn't exactly trip off the
+tongue, so I thought maybe "RebMock". That sounded like Scooby-Doo saying
+"WebMock", although he'd probably say "RebRock". That sounded almost like
+"RedRock", which is where I stopped.  I'm a bit surprised that there isn't
+already a redrock gem, given that a ruby is basically a red rock, but hey,
+you've had seven years or so.
+
+== Other random stuff
+
+Version 0.1.0 was released on Whyday, 19 August 2010.
+
+RedRock is intended to replace FakeTTP[link:http://github.com/kerryb/fakettp],
+which no-one apart from me and a few colleagues ever used.

data/lib/redrock/server.rb

@@ -0,0 +1,43 @@
+require "thin"
+require "net/http"
+require "json"
+require "webmock"
+require "webmock/rspec"
+
+Thin::Logging.silent = true
+
+module RedRock
+  class Server
+    include Singleton
+    include WebMock
+    include WebMock::Matchers
+
+    def call env
+      request = Rack::Request.new env
+      http_method = request.request_method
+      request_body = request.body.read
+      request_headers = {}
+      env.each do |k, v|
+        request_headers[k.sub(/^HTTP_/, '')] = v if k =~ /^HTTP_|CONTENT_TYPE|CONTENT_LENGTH/
+      end
+      begin
+        ::Net::HTTP.start(request_headers["HOST"]) do |http|
+          request_class = ::Net::HTTP.const_get(http_method.capitalize)
+          path = request.path_info
+          path << "?#{request.query_string}" unless request.query_string.empty?
+          request = request_class.new request.path_info, request_headers
+          request.body = request_body unless request_body.empty?
+          @response = http.request request
+        end
+      rescue WebMock::NetConnectNotAllowedError => e
+        return [500,
+          {"Content-Type" => "text/plain", "Content-Length" => e.message.length.to_s},
+          e.message]
+      end
+      response_headers = {}
+      @response.to_hash.each {|k,v| response_headers[k] = v.join "\n"}
+      response_headers.delete "status"
+      [@response.code, response_headers, @response.body]
+    end
+  end
+end

data/lib/redrock.rb

@@ -0,0 +1,33 @@
+require "redrock/server"
+
+module RedRock
+  def start port = 4242
+    raise "RedRock is already running" if @server_thread
+    @server_thread = Thread.new do
+      Thin::Server.start('0.0.0.0', port) do
+        run RedRock::Server.instance
+      end
+    end
+  end
+
+  def stop
+    if @server_thread
+      @server_thread.exit
+      @server_thread = nil
+    end
+  end
+
+  def allow_net_connect!
+    raise "RedRock does not support allowing real connections"
+  end
+
+  def disable_net_connect!
+    raise "RedRock does not support disabling real connections"
+  end
+
+  def method_missing name, *args, &block
+    super unless Server.instance.respond_to? name
+    start unless @server_thread
+    Server.instance.send name, *args, &block
+  end
+end

data/spec/redrock_spec.rb

@@ -0,0 +1,465 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+# Mostly uses curb to avoid going via net/http, to prove that the stubbing
+# isn't happening locally.
+
+describe RedRock do
+  after do
+    RedRock.stop
+  end
+
+  context "server" do
+    it "listens on port 4242 by default" do
+      stub_request :any, "localhost:4242"
+      curl = Curl::Easy.http_get "http://localhost:4242"
+      curl.response_code.should == 200
+    end
+
+    it "allows the port to be overridden" do
+      RedRock.start 4567
+      stub_request :any, "localhost:4567"
+      curl = Curl::Easy.http_get "http://localhost:4567"
+      curl.response_code.should == 200
+    end
+
+    it "silently ignores attempts to stop non-running server" do
+      lambda {RedRock.stop}.should_not raise_error
+    end
+
+    it "only runs one server at a time" do
+      RedRock.start 4567
+      lambda {RedRock.start 4568}.should raise_error(RuntimeError, "RedRock is already running")
+    end
+  end
+
+  context "on receipt of an unexpected request" do
+    let(:curl) { Curl::Easy.http_get "http://localhost:4567" }
+
+    it "returns a 500 error" do
+      curl.response_code.should == 500
+    end
+
+    it "returns a useful message in the body" do
+      curl.body_str.should =~ /Real HTTP connections are disabled/
+    end
+  end
+
+  context "stubbing with URI only and default response" do
+    before do
+      stub_request :any, "localhost:4242/foo"
+    end
+
+    it "accepts matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242/foo"
+      curl.response_code.should == 200
+    end
+
+    it "rejects non-matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242/bar"
+      curl.response_code.should == 500
+    end
+  end
+
+  context "stubbing with method, URI, body and headers" do
+    before do
+      stub_request(:any, "localhost:4242/foo").with(:body => "onion", :headers => { "bacon-preference" => "chunky" })
+    end
+
+    it "accepts matching requests" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "onion" do |c|
+        c.headers["bacon-preference"] = "chunky"
+      end
+      curl.response_code.should == 200
+    end
+
+    it "rejects requests with the wrong URI" do
+      curl = Curl::Easy.http_post "http://localhost:4242/bar", "onion" do |c|
+        c.headers["bacon-preference"] = "chunky"
+      end
+      curl.response_code.should == 500
+    end
+
+    it "rejects requests with the wrong body" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "cabbage" do |c|
+        c.headers["bacon-preference"] = "chunky"
+      end
+      curl.response_code.should == 500
+    end
+
+    it "rejects requests with the wrong headers" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "onion" do |c|
+        c.headers["bacon-preference"] = "streaky"
+      end
+      curl.response_code.should == 500
+    end
+  end
+
+  context "matching request body and headers against regular expressions" do
+    before do
+      stub_request(:any, "localhost:4242/foo").with(:body => /nion/, :headers => { "bacon-preference" => /c.*y/ })
+    end
+
+    it "accepts matching requests" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "onion" do |c|
+        c.headers["bacon-preference"] = "chunky"
+      end
+      curl.response_code.should == 200
+    end
+
+    it "rejects requests with the wrong body" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "neon" do |c|
+        c.headers["bacon-preference"] = "crispy"
+      end
+      curl.response_code.should == 500
+    end
+
+    it "rejects requests with the wrong headers" do
+      curl = Curl::Easy.http_post "http://localhost:4242/foo", "bunion" do |c|
+        c.headers["bacon-preference"] = "streaky"
+      end
+      curl.response_code.should == 500
+    end
+  end
+
+  context "matching request body against a hash" do
+    before do
+      stub_http_request(:post, "localhost:4242").with(:body => {:data => {:a => '1', :b => 'five'}})
+    end
+
+    it "matches URL-encoded data" do
+      curl = Curl::Easy.http_post "http://localhost:4242/", "data[a]=1&data[b]=five" do |c|
+        c.headers["Content-Type"] = "application/x-www-form-urlencoded"
+      end
+      curl.response_code.should == 200
+    end
+
+    it "matches JSON data" do
+      curl = Curl::Easy.http_post "http://localhost:4242/", %({"data":{"a":"1","b":"five"}}) do |c|
+        c.headers["Content-Type"] = "application/json"
+      end
+      curl.response_code.should == 200
+    end
+
+    it "matches XML data" do
+      curl = Curl::Easy.http_post "http://localhost:4242/", %(<data a="1" b="five" />) do |c|
+        c.headers["Content-Type"] = "application/xml"
+      end
+      curl.response_code.should == 200
+    end
+  end
+
+  context "matching multiple headers with the same name" do
+    before do
+      stub_http_request(:get, "localhost:4242").with(:headers => {"Accept" => ["image/jpeg", "image/png"]})
+    end
+
+    it "matches when both header values are present" do
+      # Curb can't do multiple headers with the same name
+      req = Net::HTTP::Get.new("/")
+      req['Accept'] = ['image/png']
+      req.add_field('Accept', 'image/jpeg')
+      resp = Net::HTTP.start("localhost:4242") {|http|  http.request(req) }
+      resp.should be_an_instance_of Net::HTTPOK
+    end
+
+    it "rejects requests with missing values" do
+      curl = Curl::Easy.http_get "http://localhost:4242/" do |c|
+        c.headers["Accept"] = "image/jpeg"
+      end
+      curl.response_code.should == 500
+    end
+  end
+
+  context "matching requests against a block" do
+    before do
+      stub_request(:post, "localhost:4242").with { |request| request.body == "abc" }
+    end
+
+    it "matches when the block returns true" do
+      curl = Curl::Easy.http_post "http://localhost:4242", "abc"
+      curl.response_code.should == 200
+    end
+
+    it "does not match when the block returns false" do
+      curl = Curl::Easy.http_post "http://localhost:4242", "def"
+      curl.response_code.should == 500
+    end
+  end
+
+  context "using basic auth" do
+    before do
+      stub_request(:get, "user:pass@localhost:4242")
+    end
+
+    it "matches when the username and password are correct" do
+      curl = Curl::Easy.http_get "http://localhost:4242/" do |c|
+        c.http_auth_types = :basic
+        c.username = "user"
+        c.password = "pass"
+      end
+      curl.response_code.should == 200
+    end
+  end
+
+  context "matching URIs against regular expressions" do
+    before do
+      stub_request :any, %r(local.*/foo)
+    end
+
+    it "accepts matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242/wibble/foo"
+      curl.response_code.should == 200
+    end
+
+    it "rejects non-matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242/bar"
+      curl.response_code.should == 500
+    end
+  end
+
+  context "matching query params using a hash" do
+    before do
+      stub_http_request(:get, "localhost:4242").with(:query => {"a" => ["b", "c"]})
+    end
+
+    it "accepts matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242?a[]=b&a[]=c"
+      curl.response_code.should == 200
+    end
+
+    it "rejects non-matching requests" do
+      curl = Curl::Easy.http_get "http://localhost:4242?a[]=d"
+      curl.response_code.should == 500
+    end
+  end
+
+  context "returning a custom response" do
+    before do
+      stub_request(:any, "localhost:4242").to_return(:body => "abc", :status => 201,
+                                                     :headers => { "Location" => "nowhere"})
+    end
+
+    let(:curl) { Curl::Easy.http_get "http://localhost:4242" }
+
+    it "returns the specified body" do
+      curl.body_str.should == "abc"
+    end
+
+    it "returns the specified response code" do
+      curl.response_code.should == 201
+    end
+
+    it "returns the specified headers" do
+      curl.header_str.should =~ /location: nowhere/
+    end
+  end
+
+  it "supports specification of a response body as an IO object" do
+    stub_request(:any, "localhost:4242").to_return(:body => StringIO.new("chunky bacon"), :status => 200)
+    curl = Curl::Easy.http_get "http://localhost:4242"
+    curl.body_str.should == "chunky bacon"
+  end
+
+  context "returning a custom status message" do
+    before do
+      stub_request(:any, "localhost:4242").to_return(:status => [500, "Pixies are on strike"])
+    end
+
+    let(:resp) do
+      uri = URI.parse "http://localhost:4242"
+      Net::HTTP.start(uri.host, uri.port) {|http|
+        http.get "/"
+      }
+    end
+
+    it "returns the specified response code" do
+      resp.code.should == "500"
+    end
+
+    it "returns the specified message" do
+      resp.message.should == "Pixies are on strike"
+    end
+  end
+
+  context "replaying raw responses recorded with curl -is" do
+    let(:raw_response) do
+      <<-EOF
+HTTP/1.1 200 OK
+Date: Wed, 18 Aug 2010 13:24:53 GMT
+Server: Apache/2.2.14 (Unix) mod_ssl/2.2.14 OpenSSL/0.9.8l DAV/2 Phusion_Passenger/2.2.11
+Last-Modified: Mon, 29 Jun 2009 12:57:40 GMT
+ETag: "13b358c-117-46d7c3c301900"
+Accept-Ranges: bytes
+Content-Length: 13
+Content-Type: text/p[ain
+
+Chunky bacon!
+      EOF
+    end
+
+    shared_examples_for "a raw response" do
+      it "returns the response" do
+        curl = Curl::Easy.http_get "http://localhost:4242"
+        curl.body_str.should == "Chunky bacon!"
+      end
+    end
+
+    context "as a file" do
+      before do
+        File.open "response", "w" do |f|
+          f.puts raw_response
+        end
+        stub_request(:any, "localhost:4242").to_return File.new("response")
+      end
+
+      after do
+        FileUtils.rm_rf "response"
+      end
+
+      it_should_behave_like "a raw response"
+    end
+
+    context "as a string" do
+      before do
+        stub_request(:any, "localhost:4242").to_return raw_response
+      end
+
+      it_should_behave_like "a raw response"
+    end
+  end
+
+  context "dynamically evaluating responses" do
+    shared_examples_for "a dynamic response" do
+      it "returns the correct response" do
+        curl = Curl::Easy.http_post "http://localhost:4242", "!nocab yknuhC"
+        curl.body_str.should == "Chunky bacon!"
+      end
+    end
+
+    context "from a block" do
+      before do
+        stub_request(:any, "localhost:4242").to_return { |request| {:body => request.body.reverse} }
+      end
+
+      it_should_behave_like "a dynamic response"
+    end
+
+    context "from a lambda" do
+      before do
+        stub_request(:any, "localhost:4242").to_return(lambda { |request| {:body => request.body.reverse} })
+      end
+
+      it_should_behave_like "a dynamic response"
+    end
+
+    context "by part" do
+      before do
+        stub_request(:any, "localhost:4242").to_return(:body => lambda { |request| request.body.reverse })
+      end
+
+      it_should_behave_like "a dynamic response"
+    end
+  end
+
+  context "setting multiple responses" do
+    shared_examples_for "multiple responses" do
+      it "returns the correct values" do
+        curl = Curl::Easy.new "http://localhost:4242"
+        (1..3).map do
+          curl.http_get
+          curl.body_str
+        end.should == %w(chunky chunky bacon)
+      end
+    end
+
+    context "individually" do
+      before do
+        stub_request(:get, "localhost:4242").to_return({:body => "chunky"},
+                                                       {:body => "chunky"},
+                                                       {:body => "bacon"})
+      end
+
+      it_should_behave_like "multiple responses"
+    end
+
+    context "using method chaining" do
+      before do
+        stub_request(:get, "localhost:4242").to_return({:body => "chunky"}).then.
+          to_return({:body => "chunky"}).then.to_return({:body => "bacon"})
+      end
+
+      it_should_behave_like "multiple responses"
+    end
+
+    context "specifying the number of times to return a given response" do
+      before do
+        stub_request(:get, "localhost:4242").to_return({:body => "chunky"}).times(2).then.
+          to_return({:body => "bacon"})
+      end
+
+      it_should_behave_like "multiple responses"
+    end
+  end
+
+  context "assertions" do
+    before do
+      stub_request :any, "localhost:4242/foo"
+      Curl::Easy.http_get "http://localhost:4242/foo"
+    end
+
+    context "in the test/unit style" do
+      it "can assert requests made" do
+        assert_requested :get, "http://localhost:4242/foo"
+      end
+
+      it "can assert requests not made" do
+        assert_not_requested :get, "http://localhost:4242/bar"
+      end
+    end
+
+    context "in the rspec style" do
+      it "can assert requests made" do
+        RedRock.should have_requested :get, "http://localhost:4242/foo"
+      end
+
+      it "can assert requests not made" do
+        RedRock.should_not have_requested :get, "http://localhost:4242/bar"
+      end
+    end
+
+    context "in the alternative rspec style" do
+      it "can assert requests made" do
+        request(:get, "http://localhost:4242/foo").should have_been_made
+      end
+
+      it "can assert requests not made" do
+        request(:get, "http://localhost:4242/bar").should_not have_been_made
+      end
+    end
+  end
+
+  context "resetting" do
+    before do
+      stub_request :any, "localhost:4242"
+      Curl::Easy.http_get "http://localhost:4242"
+      reset_webmock
+    end
+
+    it "clears stubs" do
+      curl = Curl::Easy.http_get "http://localhost:4242"
+      curl.response_code.should == 500
+    end
+
+    it "clears history" do
+      request(:get, "http://localhost:4242").should_not have_been_made
+    end
+  end
+
+  it "does not support enabling local requests" do
+    lambda {allow_net_connect!}.should raise_error RuntimeError, "RedRock does not support allowing real connections"
+  end
+
+  it "does not support disabling local requests" do
+    lambda {disable_net_connect!}.should raise_error RuntimeError, "RedRock does not support disabling real connections"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "spec"
+require "curb"
+require "stringio"
+require "redrock"
+include RedRock
+require "webmock/test_unit"
+require "webmock/rspec"

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: redrock
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kerry Buckley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thin
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: curb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: 
+email: kerryjbuckley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- spec/redrock_spec.rb
+- spec/spec_helper.rb
+- lib/redrock/server.rb
+- lib/redrock.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/kerryb/redrock
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Proxy for using WebMock remotely
+test_files: []
+