http_capture 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzNhYzU1NDc2OWRlNjI1YjVlMTNjZDE3YTQ4NWZmMDQ5MWUxZTU1Mw==
+  data.tar.gz: !binary |-
+    M2JkOWFhNWU0MmJjOGYzZGZkMDE0ZmQ2OTdjODI3MDI1ZDc5YTcyNw==
+SHA512:
+  metadata.gz: !binary |-
+    YjhkMjI0Y2M5NjRjYWFkZWU1OWMxMTk1MzRlZWQ4YzM3YjkwM2EwNGVkMDNh
+    ZDRjOGFhN2M0ZmVkODBjNTFlNWY5OTkzZGIzODJmMWIwZTNhMTQ1Mzk5MDEz
+    MTk3MjA0MGZhZGVkOGY3NTk3OWQzZjAwYjE4ZDZiNTFmMTAxMmE=
+  data.tar.gz: !binary |-
+    ZmYxZjBlZDE4N2Y4MjI3MWMzYjhhZTE5MDNkZjc0OWYzMDI5NDc3ZThlMGZh
+    N2E5YTAxYTkzNGEwY2JkYTQ4YTQ1NjAwN2ZhMWViNTAyODEzOTNjMTU3YjFh
+    ODc1OGY1NDhhNTk5MWE3OTBkYjhlOTE4MmIxY2IzZWQzZWMwYjM=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log

data/.rspec

@@ -0,0 +1,5 @@
+--no-color
+--require spec_helper
+--format progress -o log/spec.log
+--format html     -o log/spec.html
+-cfs

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.2
+deploy:
+  provider: rubygems
+  api_key:
+    secure: G2rk3KCBDCD0QDbKJtTXsdtWlfSewvBImu90oaBBlVW97v423GfQ+xRWH2amHBIw0UYwgqDDnMAG38oAovKcYgFe3dHNwKIrwLsZDEL7syOa68P5swOsYaGLboZjSFcfjFWqfp6UcrBNeVjzdaXcbIJK8c+UTCpt/zUnDYFj/zo=
+  gem: http_capture
+  on:
+    repo: blinkboxbooks/http_capture.rb
+    rvm: 2.1.2
+    branch: master

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change log
+
+## 0.2.0 2014-07-01 10:05:00
+
+Manually bumped version when going to Artifactory
+
+## 0.0.1 ([#7](https://git.mobcastdev.com/TEST/http_capture/pull/7) 2014-06-30 16:51:38)
+
+Artifactory
+
+### Improvement
+
+- Move to the use of artifactory
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 blinkbox Books Ltd.
+
+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,48 @@
+# HTTP Capture
+
+Allows access to the responses from a wide range of ruby HTTP libraries. This is super helpful for testing (especially with Cucumber).
+
+Currently supports:
+
+* [Net::HTTP](http://ruby-doc.org/stdlib-2.0/libdoc/net/http/rdoc/Net/HTTP.html) (and anything that uses it, specifically including:)
+    * [Mechanize](http://mechanize.rubyforge.org/)
+    * [HTTParty](http://httparty.rubyforge.org/rdoc/)
+* [HTTPClient](http://rubydoc.info/gems/httpclient/2.1.5.2/HTTPClient)
+* [Rack::Test](http://rdoc.info/github/brynary/rack-test/master/frames)
+
+They can all be used by requiring `<library folder space>/capture` from your code, eg:
+
+    require 'net/http/capture'
+    require 'mechanize/capture'
+    require 'httparty/capture'
+    require 'httpclient/capture'
+    require 'rack/test/capture'
+
+## Install
+
+Install the usual way:
+    
+    $ gem install http_capture
+
+Or require it from within your gemspec and use `bundle`.
+
+## Usage
+
+Because it's beneficial to use a number of different HTTP libraries during our testing I've written a small script to capture the HTTP response information from each of the supported libraries so they can be examined after-the-fact. For example:
+
+    require 'httpclient'
+    # Include the relevant capture library
+    require 'httpclient/capture'
+
+    # Perform a request, as usual
+    clnt = HTTPClient.new
+    clnt.get_content("http://google.com") # => "<html>..."
+
+    # Now you can retrieve all the captured responses:
+    HttpCapture::RESPONSES.last.status # => 200
+    HttpCapture::RESPONSES.last['Content-Length'] # => 12345
+    HttpCapture::RESPONSES.last.body # => "<html>..."
+    HttpCapture::RESPONSES.last.response # => <HTTPClient::Response>
+
+The objects in the `HttpCapture::RESPONSES` array contain the exact objects, wrapped by helper functions which expose three methods: `code` for the status code, `[](key)` for accessing headers and `body` for reading the body of the document.
+

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require 'bundler/gem_tasks'
+
+task :default => :build
+task :build => :test
+task :test => :spec
+
+desc "Run all rspec tests"
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+rescue LoadError => e
+  raise e
+  task :spec do
+    $stderr.puts "Please install rspec: `gem install rspec`"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/http_capture.gemspec

@@ -0,0 +1,32 @@
+($LOAD_PATH << File.expand_path("../lib", __FILE__)).uniq!
+require "http_capture/version"
+
+Gem::Specification.new do |s|
+  s.name = "http_capture"
+  s.version = HttpCapture::VERSION
+  s.summary = "Captures http responses from a number of libraries for testing."
+  s.description = "Captures the Response objects from HTTParty, Mechanize, Net::HTTP, HTTPClient and Rack::Test and abstracts them for use in testing libraries."
+  s.author = "blinkbox books"
+  s.email = "jphastings@blinkbox.com"
+  s.homepage = "http://www.blinkboxbooks.com"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split($/)
+  s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = ["README.md"]
+
+  s.post_install_message = ":: Coded for blinkbox books :: Love books, love code? Get in touch ::"
+
+  # These are the supported libraries.
+  s.add_development_dependency "rack-test", "~> 0.6"
+  s.add_development_dependency "mechanize", "~> 2.7"
+  s.add_development_dependency "httpclient", "~> 2.3"
+  s.add_development_dependency "httparty", "~> 0.11"
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake", "~> 10.1"
+  s.add_development_dependency "rspec", "~> 2.99"
+  s.add_development_dependency "sinatra"
+end

data/lib/http_capture.rb

@@ -0,0 +1,99 @@
+require 'http_capture/version'
+
+# Contains functionality to capture HTTP traffic from a variety of libraries.
+module HttpCapture
+  RESPONSES = []
+
+  # Represents a captured request.
+  class Request
+    def initialize(real_request)
+      @real_request = real_request
+    end
+
+    # The request method as an upper-case string.
+    def method
+      if @real_request.respond_to?(:request_method)
+        @real_request.request_method.to_s.upcase
+      else
+        @real_request.method.to_s.upcase
+      end
+    end
+
+    # The request path.
+    def path
+      @real_request.path
+    end
+
+    # The complete request URI.
+    def uri
+      uri = if @real_request.respond_to?(:uri)
+              @real_request.uri
+            else
+              @real_request.url
+            end
+      uri = URI.parse(uri.to_s) unless uri.is_a?(URI)
+      uri
+    end
+  end
+
+  # Represents a captured response.
+  class Response
+    include Enumerable
+
+    # The request that this is a response to.
+    attr_reader :request
+
+    # The duration of the request in seconds.
+    attr_reader :duration
+
+    def initialize(real_response, request: nil, duration: nil)
+      @real_response = real_response
+      @request = request
+      @duration = duration
+    end
+
+    # Provides access to the response headers.
+    def [](key)
+      if @real_response.respond_to?(:[])
+        @real_response[key]
+      elsif @real_response.respond_to?(:headers)
+        @real_response.headers[key]
+      elsif @real_response.respond_to?(:header)
+        @real_response.header[key]
+      end
+    end
+
+    def each(&block)
+      # some of the libraries return just header names in the each method; others return the header name and value
+      # as an array. some downcase the header name but others leave them as they were. this adapts them to the most
+      # useful and consistent which is an array of [name, value] with the name in lower case.
+      action = Proc.new { |item| block.(item.is_a?(String) ? [item.downcase, self[item]] : item) }
+      if @real_response.respond_to?(:each)
+        @real_response.each &action
+      elsif @real_response.respond_to?(:headers)
+        @real_response.headers.each &action
+      elsif @real_response.respond_to?(:header)
+        @real_response.header.each &action
+      end        
+    end
+
+    # The default status code accessor
+    def status
+      if @real_response.respond_to?(:code)
+        @real_response.code.to_i
+      else
+        @real_response.status.to_i
+      end
+    end
+
+    # The default body accessor
+    def body
+      @real_response.body
+    end
+
+    # Whether the request was successful.
+    def successful?
+      status >= 200 && status < 300
+    end
+  end
+end

data/lib/http_capture/version.rb

@@ -0,0 +1,3 @@
+module HttpCapture
+  VERSION = File.read(File.join(__dir__,"../../VERSION")) rescue "0.1.0"
+end

data/lib/httparty/capture.rb

@@ -0,0 +1,4 @@
+require 'httparty'
+require 'net/http/capture'
+
+# Doesn't need anything extra as Net::HTTP takes care of everything

data/lib/httpclient/capture.rb

@@ -0,0 +1,53 @@
+require 'httpclient'
+require 'http_capture'
+
+class HTTPClient
+  alias :old_do_request :do_request
+  def do_request(method, uri, query, body, header, &block)
+    start_time = Time.now.to_f
+    real_response = old_do_request(method, uri, query, body, header, &block)
+    duration = Time.now.to_f - start_time
+
+    captured_request = HttpCapture::HTTPClientRequest.new(method, uri, query)
+    captured_response = HttpCapture::HTTPClientResponse.new(real_response, request: captured_request, duration: duration)
+    HttpCapture::RESPONSES.push(captured_response)
+
+    real_response
+  end
+
+  alias :old_get_content :get_content
+  def get_content(uri, *args, &block)
+    query, header = keyword_argument(args, :query, :header)
+    success_content(follow_redirect(:get, uri, query, nil, header || {}, &block))
+  end
+end
+
+# Modifications of the base class to work with HTTPClient
+module HttpCapture
+  class HTTPClientRequest < Request
+    attr_reader :method, :path, :uri
+
+    def initialize(method, uri, query)
+      super(nil)
+      @method = method.to_s.upcase
+      @path = uri
+      if query
+        query = Rack::Utils.build_query(query) unless query.is_a?(String)
+        @uri = URI.parse("#{uri}?#{query}")
+      else
+        @uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+      end
+    end
+  end
+
+  class HTTPClientResponse < Response
+    # def each
+    #   @real_response.headers.each { |array| yield array.join(", ") }
+    # end
+
+    # Body access
+    def body
+      @real_response.content
+    end
+  end
+end

data/lib/mechanize/capture.rb

@@ -0,0 +1,4 @@
+require 'mechanize'
+require 'http_capture'
+
+# Doesn't need anything extra as Net::HTTP takes care of everything

data/lib/net/http/capture.rb

@@ -0,0 +1,39 @@
+require 'net/http'
+require 'http_capture'
+
+module Net
+  class HTTP
+    alias :old_request :request    
+    def request(req, body = nil, &block)
+      start_time = Time.now.to_f
+      real_response = old_request(req, body, &block)
+      duration = Time.now.to_f - start_time
+
+      captured_request = HttpCapture::Request.new(req)
+      captured_response = HttpCapture::NetHTTPResponse.new(real_response, request: captured_request, duration: duration)
+      HttpCapture::RESPONSES.push(captured_response)
+
+      real_response
+    end
+  end
+
+  class ReadAdapter
+    attr_reader :stored_body
+
+    alias :old_write_to :<<
+    # If a block is used to process the incoming body data, ensure we're keeping it for inspection later too
+    def <<(str)
+      (@stored_body ||= '') << str
+      old_write_to(str)
+    end
+  end
+end
+
+module HttpCapture
+  class NetHTTPResponse < HttpCapture::Response
+    def body
+      return @real_response.body.stored_body if @real_response.body.respond_to? :stored_body
+      @real_response.body
+    end
+  end
+end

data/lib/rack/test/capture.rb

@@ -0,0 +1,35 @@
+require 'rack/test'
+require 'http_capture'
+
+module Rack
+  class MockSession
+    # I *do not* like replicating functionality (this is a copy of the code from within rack/test's `Rack::MockSession`)
+    # but for some reason this method pushes out an array, not the expected `@last_response` if I just call it with the
+    # usual `alias` method. This works, let's leave it at that for now!
+    def request(uri, env)
+      env["HTTP_COOKIE"] ||= cookie_jar.for(uri)
+
+      @last_request = Rack::Request.new(env)
+      start_time = Time.now.to_f
+      status, headers, body = @app.call(@last_request.env)
+      duration = Time.now.to_f - start_time
+
+      @last_response = MockResponse.new(status, headers, body, env["rack.errors"].flush)
+      captured_request = HttpCapture::Request.new(@last_request)
+      captured_response = HttpCapture::Response.new(@last_response, request: captured_request, duration: duration)
+      HttpCapture::RESPONSES.push(captured_response)
+
+      body.close if body.respond_to?(:close)
+
+      cookie_jar.merge(last_response.headers["Set-Cookie"], uri)
+
+      @after_request.each { |hook| hook.call }
+
+      if @last_response.respond_to?(:finish)
+        @last_response.finish
+      else
+        @last_response
+      end
+    end
+  end
+end

data/spec/capture_spec.rb

@@ -0,0 +1,68 @@
+require 'net/http/capture'
+
+shared_examples "capturing HTTP responses" do
+  before :each do
+    # Clear the captured requests
+    HttpCapture::RESPONSES.clear
+  end
+
+  it 'should capture a HTTP GET request' do
+    # Do the request
+    perform_get(make_test_uri())
+
+    # Really I should check that it has exactly 1 item, but for now we're happy that something comes through.
+    HttpCapture::RESPONSES.length.should > 0
+  end
+
+  context 'last captured response wrapper' do
+    before :all do
+      HttpCapture::RESPONSES.clear
+      perform_get(make_test_uri(200, "text"))
+      @it = HttpCapture::RESPONSES.last
+    end
+    
+    it 'should capture the request that triggered the response' do
+      expect(@it.request).to_not be_nil
+    end
+    
+    it 'should record the time it took to get the response with the #duration method' do
+      expect(@it.duration).to be > 0
+    end
+    
+    it 'should return headers with the #[](key) method' do
+      expect(@it['Content-Length']).to be_a_kind_of(String)
+    end
+
+    it 'should support enumerating the headers with the #each method' do
+      @it.each { |item| expect(item).to be_a_kind_of(Array) }
+    end
+
+    it 'should return the status with the #status method' do
+      expect(@it.status).to eq(200)
+    end
+
+    it 'should return the body with the #body method' do
+      expect(@it.body).to eq("text")
+    end
+  end
+
+  context('last captured request wrapper') do
+    before :all do
+      HttpCapture::RESPONSES.clear
+      perform_get(make_test_uri(200, "text"))
+      @it = HttpCapture::RESPONSES.last.request
+    end
+
+    it 'should return the method with the #method method' do
+      expect(@it.method).to eq("GET")
+    end
+
+    it 'should return the path with the #path method' do
+      expect(@it.path).to_not be_nil # TODO: This should be a stronger check...
+    end
+
+    it 'should return the full URI with the #uri method' do
+      expect(@it.uri).to be_a_kind_of(URI)
+    end
+  end  
+end

data/spec/httparty/capture_spec.rb

@@ -0,0 +1,10 @@
+require 'httparty'
+require 'httparty/capture'
+
+describe HTTParty do
+    include_examples "capturing HTTP responses"
+    
+    def perform_get(uri)
+        HTTParty.get(uri)
+    end
+end

data/spec/httpclient/capture_spec.rb

@@ -0,0 +1,11 @@
+require 'httpclient'
+require 'httpclient/capture'
+
+describe HTTPClient do
+    include_examples "capturing HTTP responses"
+    
+    def perform_get(uri)
+        clnt = HTTPClient.new
+        clnt.get_content(uri)
+    end
+end

data/spec/mechanize/capture_spec.rb

@@ -0,0 +1,11 @@
+require 'mechanize'
+require 'mechanize/capture'
+
+describe Mechanize do
+    include_examples "capturing HTTP responses"
+    
+    def perform_get(uri)
+        a = Mechanize.new
+        a.get(uri)
+    end
+end

data/spec/net/http/capture_spec.rb

@@ -0,0 +1,13 @@
+require 'net/http'
+require 'net/http/capture'
+require 'uri'
+
+describe Net::HTTP do
+    include_examples "capturing HTTP responses"
+    
+    def perform_get(uri)
+        uri = URI.parse(uri)
+
+        Net::HTTP.get_response(uri)
+    end
+end

data/spec/rack/test/capture_spec.rb

@@ -0,0 +1,16 @@
+require 'rack/test'
+require 'rack/test/capture'
+
+describe Rack::Test do
+  include_examples "capturing HTTP responses"
+  include Rack::Test::Methods
+
+  # This spins up an in-process version of the app for testing with rack-test
+  def app
+    TestingApp.new
+  end
+
+  def perform_get(uri)
+    get(uri)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+require 'webrick'
+require 'sinatra/base'
+require 'uri'
+require 'logger'
+
+# This app allows us to make real HTTP responses from tests
+class TestingApp < Sinatra::Base
+  # Call this with /?body=the_body&code=200&headers[Content-Type]=text/plain
+  get '/' do
+    halt params['code'].to_i, params['body']
+  end
+end
+
+# Windows requires a different descriptor for "ignore the logs"
+dev_null = case RUBY_PLATFORM
+when /cygwin|mswin|mingw|bccwin|wince|emx/
+  "nul"
+else
+  "/dev/null"
+end
+
+# Start the real server on any open port
+$server = ::WEBrick::HTTPServer.new({
+  :BindAddress => '127.0.0.1',
+  :Port => 0,
+  :OutputBufferSize => 5,
+  :Logger => WEBrick::Log.new(dev_null),
+  :AccessLog => []
+})
+
+# Mount the testing app for the tests to hit
+$server.mount "/", Rack::Handler::WEBrick, TestingApp.new
+
+# Ensure we don't start the tests until the server is ready
+$ready = false
+$server.config[:StartCallback] = Proc.new{ $ready = true }
+
+$server.config[:Logger].level = Logger::ERROR
+
+# Start the server in another thread
+Thread.new do
+  $server.start
+end
+
+# Wait for the server to be ready
+while not $ready
+end
+
+# TODO: Enclose this somewhere useful
+def make_test_uri(code = 200, body = '', headers = {})
+  u = URI.parse("http://127.0.0.1:#{$server.config[:Port]}/")
+
+  u.query = "code=#{code.to_i.to_s}&body=#{URI.encode(body)}"
+  headers.each_pair do |key, value|
+      u.query << "&headers[#{URI.encode(key)}]=#{URI.encode(value)}"
+  end
+
+  u.to_s
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: http_capture
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- blinkbox books
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.99'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Captures the Response objects from HTTParty, Mechanize, Net::HTTP, HTTPClient
+  and Rack::Test and abstracts them for use in testing libraries.
+email: jphastings@blinkbox.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- http_capture.gemspec
+- lib/http_capture.rb
+- lib/http_capture/version.rb
+- lib/httparty/capture.rb
+- lib/httpclient/capture.rb
+- lib/mechanize/capture.rb
+- lib/net/http/capture.rb
+- lib/rack/test/capture.rb
+- spec/capture_spec.rb
+- spec/httparty/capture_spec.rb
+- spec/httpclient/capture_spec.rb
+- spec/mechanize/capture_spec.rb
+- spec/net/http/capture_spec.rb
+- spec/rack/test/capture_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.blinkboxbooks.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: ':: Coded for blinkbox books :: Love books, love code? Get in
+  touch ::'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Captures http responses from a number of libraries for testing.
+test_files:
+- spec/capture_spec.rb
+- spec/httparty/capture_spec.rb
+- spec/httpclient/capture_spec.rb
+- spec/mechanize/capture_spec.rb
+- spec/net/http/capture_spec.rb
+- spec/rack/test/capture_spec.rb
+- spec/spec_helper.rb