social_url_stats 0.0.1

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/configuration_stubbing.rb

@@ -0,0 +1,8 @@
+shared_context "configuration stubbing" do
+  let(:config) { double("VCR::Configuration") }
+
+  before do
+    allow(VCR).to receive(:configuration) { config }
+  end
+end
+

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/fixnum_extension.rb

@@ -0,0 +1,10 @@
+unless 7.respond_to?(:days)
+  class Fixnum
+    def days
+      self *
+      24 * # hours
+      60 * # minutes
+      60   # seconds
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/http_library_adapters.rb

@@ -0,0 +1,285 @@
+module HeaderDowncaser
+  def downcase_headers(headers)
+    {}.tap do |downcased|
+      headers.each do |k, v|
+        downcased[k.downcase] = v
+      end
+    end
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS = {}
+
+HTTP_LIBRARY_ADAPTERS['net/http'] = Module.new do
+  include HeaderDowncaser
+
+  def self.http_library_name; 'Net::HTTP'; end
+
+  def get_body_string(response); response.body; end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.get_fields(header_key)
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    uri = URI.parse(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    if uri.scheme == "https"
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    http.send_request(method.to_s.upcase, uri.request_uri, body, headers)
+  end
+
+  DEFAULT_REQUEST_HEADERS = { "Accept"=>["*/*"] }
+  DEFAULT_REQUEST_HEADERS['User-Agent'] = ["Ruby"] if RUBY_VERSION.to_f > 1.8
+  DEFAULT_REQUEST_HEADERS['Accept-Encoding'] = ["gzip;q=1.0,deflate;q=0.6,identity;q=0.3"] if RUBY_VERSION.to_f > 1.9
+
+  def normalize_request_headers(headers)
+    defined?(super) ? super :
+    downcase_headers(headers.merge(DEFAULT_REQUEST_HEADERS))
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['patron'] = Module.new do
+  def self.http_library_name; 'Patron'; end
+
+  def get_body_string(response); response.body; end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.headers[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Patron::Session.new.request(method, url, headers, :data => body || '')
+  end
+
+  def normalize_request_headers(headers)
+    headers.merge('Expect' => [''])
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['httpclient'] = Module.new do
+  def self.http_library_name; 'HTTP Client'; end
+
+  def get_body_string(response)
+    body = response.body
+    string = body.is_a?(String) ? body : body.content
+    string.respond_to?(:read) ? string.read : string
+  end
+
+  def get_body_object(response)
+    response.body
+  end
+
+  def get_header(header_key, response)
+    response.header[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    HTTPClient.new.request(method, url, nil, body, headers)
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['em-http-request'] = Module.new do
+  def self.http_library_name; 'EM HTTP Request'; end
+
+  def get_body_string(response)
+    response.response
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    values = response.response_header[header_key.upcase.gsub('-', '_')]
+    values.is_a?(Array) ? values : values.split(', ')
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    http = nil
+    EventMachine.run do
+      http = EventMachine::HttpRequest.new(url).send(method, :body => body, :head => headers)
+      http.callback { EventMachine.stop }
+    end
+    http
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['curb'] = Module.new do
+  def self.http_library_name; "Curb"; end
+
+  def get_body_string(response)
+    response.body_str
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    headers = response.header_str.split("\r\n")[1..-1]
+    value = nil
+    headers.each do |h|
+      next unless h =~ /^#{Regexp.escape(header_key)}: (.*)$/
+      new_value = $1.split(', ')
+      value = value ? Array(value) + Array(new_value) : new_value
+    end
+    value
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Curl::Easy.new(url) do |c|
+      c.headers = headers
+
+      if [:post, :put].include?(method)
+        c.send("http_#{method}", body)
+      else
+        c.send("http_#{method}")
+      end
+    end
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['typhoeus'] = Module.new do
+  def self.http_library_name; "Typhoeus"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    # Due to https://github.com/typhoeus/typhoeus/commit/256c95473d5d40d7ec2f5db603687323ddd73689
+    # headers are now downcased.
+    # ...except when they're not.  I'm not 100% why (I haven't had time to dig into it yet)
+    # but in some situations the headers aren't downcased.  I think it has to do with playback; VCR
+    # isn't sending the headers in downcased to typhoeus. It gets complicated with the interaction
+    # w/ WebMock, and the fact that webmock normalizes headers in a different fashion.
+    #
+    # For now this hack works.
+    response.headers.fetch(header_key.downcase) { response.headers[header_key] }
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    request = Typhoeus::Request.new(url, :method => method, :body => body, :headers => headers)
+    request.run
+    request.response
+  end
+
+  def normalize_request_headers(headers)
+    headers.merge("User-Agent"=>["Typhoeus - https://github.com/typhoeus/typhoeus"])
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['typhoeus 0.4'] = Module.new do
+  def self.http_library_name; "Typhoeus"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.headers_hash[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    Typhoeus::Request.send(method, url, :body => body, :headers => headers)
+  end
+
+  def normalize_request_headers(headers)
+    headers
+  end
+end
+
+HTTP_LIBRARY_ADAPTERS['excon'] = Module.new do
+  def self.http_library_name; "Excon"; end
+
+  def get_body_string(response)
+    response.body
+  end
+  alias get_body_object get_body_string
+
+  def get_header(header_key, response)
+    response.headers[header_key]
+  end
+
+  def make_http_request(method, url, body = nil, headers = {})
+    # There are multiple ways to use Excon but this is how fog (the main user of excon) uses it:
+    # https://github.com/fog/fog/blob/v1.1.1/lib/fog/aws/rds.rb#L139-147
+    Excon.new(url).request(:method => method.to_s.upcase, :body => body, :headers => headers)
+  end
+
+  def normalize_request_headers(headers)
+    headers.merge('User-Agent' => [Excon::USER_AGENT])
+  end
+end
+
+%w[ net_http typhoeus patron ].each do |_faraday_adapter|
+  if _faraday_adapter == 'typhoeus' &&
+     defined?(::Typhoeus::VERSION) &&
+     ::Typhoeus::VERSION.to_f >= 0.5
+    require 'typhoeus/adapters/faraday'
+  end
+
+  HTTP_LIBRARY_ADAPTERS["faraday (w/ #{_faraday_adapter})"] = Module.new do
+    class << self; self; end.class_eval do
+      define_method(:http_library_name) do
+        "Faraday (#{_faraday_adapter})"
+      end
+    end
+
+    define_method(:faraday_adapter) { _faraday_adapter.to_sym }
+
+    def get_body_string(response)
+      response.body
+    end
+    alias get_body_object get_body_string
+
+    def get_header(header_key, response)
+      value = response.headers[header_key]
+      value.split(', ') if value
+    end
+
+    def make_http_request(method, url, body = nil, headers = {})
+      url_root, url_rest = split_url(url)
+
+      faraday_connection(url_root).send(method) do |req|
+        req.url url_rest
+        headers.each { |k, v| req[k] = v }
+        req.body = body if body
+      end
+    end
+
+    def split_url(url)
+      uri = URI.parse(url)
+      url_root = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+      rest = url.sub(url_root, '')
+
+      [url_root, rest]
+    end
+
+    def faraday_connection(url_root)
+      Faraday::Connection.new(:url => url_root) do |builder|
+        builder.adapter faraday_adapter
+      end
+    end
+
+    def normalize_request_headers(headers)
+      headers.merge("User-Agent" => ["Faraday v#{Faraday::VERSION}"])
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/limited_uri.rb

@@ -0,0 +1,31 @@
+require 'forwardable'
+require 'uri'
+
+class LimitedURI
+  extend Forwardable
+
+  def_delegators :@uri, :scheme,
+                        :host,
+                        :port,
+                        :port=,
+                        :path,
+                        :query,
+                        :query=,
+                        :to_s
+
+  def initialize(uri)
+    @uri = uri
+  end
+
+  def ==(other)
+    to_s == other.to_s
+  end
+
+  def self.parse(uri)
+    return uri if uri.is_a? LimitedURI
+    return new(uri) if uri.is_a? URI
+    return new(URI.parse(uri)) if uri.is_a? String
+
+    raise URI::InvalidURIError
+  end
+end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/ruby_interpreter.rb

@@ -0,0 +1,7 @@
+RUBY_INTERPRETER = if RUBY_PLATFORM == 'java'
+  :jruby
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  :rubinius
+else
+  :mri
+end

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/shared_example_groups/excon.rb

@@ -0,0 +1,63 @@
+shared_examples "Excon streaming" do
+  context "when Excon's streaming API is used" do
+    def make_request_to(path)
+      chunks = []
+
+      Excon.get "http://localhost:#{VCR::SinatraApp.port}#{path}", :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+        chunks << chunk
+      }
+
+      chunks.join
+    end
+
+    it 'properly records and plays back the response' do
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
+      recorded, played_back = [1, 2].map do
+        make_request_to('/foo')
+      end
+
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq("FOO!")
+    end
+
+    it 'properly records and plays back the response for unexpected status' do
+      allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
+      recorded, played_back = [1, 2].map do
+        chunks = []
+
+        VCR.use_cassette('excon_streaming_error', :record => :once) do
+          begin
+            Excon.get "http://localhost:#{VCR::SinatraApp.port}/404_not_200", :expects => 200, :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+              chunks << chunk
+            }
+          rescue Excon::Errors::Error => e
+            chunks << e.response.body
+          end
+        end
+
+        chunks.join
+      end
+
+      expect(recorded).to eq(played_back)
+      expect(recorded).to eq('404 not 200')
+    end
+
+    context "when a cassette is played back and appended to" do
+      it 'does not allow Excon to mutate the response body in the cassette' do
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+          expect(make_request_to('/foo')).to eq('FOO!') # so it will save to disk again
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+      end
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/vcr-2.8.0/spec/support/shared_example_groups/hook_into_http_library.rb

@@ -0,0 +1,594 @@
+require 'cgi'
+
+NET_CONNECT_NOT_ALLOWED_ERROR = /An HTTP request has been made that VCR does not know how to handle/
+
+shared_examples_for "a hook into an HTTP library" do |library_hook_name, library, *other|
+  include HeaderDowncaser
+  include VCRStubHelpers
+
+  unless adapter_module = HTTP_LIBRARY_ADAPTERS[library]
+    raise ArgumentError.new("No http library adapter module could be found for #{library}")
+  end
+
+  http_lib_unsupported = (RUBY_INTERPRETER != :mri && library =~ /(typhoeus|curb|patron|em-http)/)
+
+  describe "using #{adapter_module.http_library_name}", :unless => http_lib_unsupported do
+    include adapter_module
+
+    # Necessary for ruby 1.9.2.  On 1.9.2 we get an error when we use super,
+    # so this gives us another alias we can use for the original method.
+    alias make_request make_http_request
+
+    1.upto(2) do |header_count|
+      describe "making an HTTP request that responds with #{header_count} Set-Cookie header(s)" do
+        define_method :get_set_cookie_header do
+          VCR.use_cassette('header_test', :record => :once) do
+            get_header 'Set-Cookie', make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/set-cookie-headers/#{header_count}")
+          end
+        end
+
+        it 'returns the same header value when recording and replaying' do
+          expect((recorded_val = get_set_cookie_header)).not_to be_nil
+          replayed_val = get_set_cookie_header
+          expect(replayed_val).to eq(recorded_val)
+        end
+      end
+    end
+
+    def self.test_record_and_playback(description, query)
+      describe "a request to a URL #{description}" do
+        define_method :get_body do
+          VCR.use_cassette('record_and_playback', :record => :once) do
+            get_body_string make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/record-and-playback?#{query}")
+          end
+        end
+
+        it "properly records and playsback a request with a URL #{description}" do
+          recorded_body = get_body
+          played_back_body = get_body
+          expect(played_back_body).to eq(recorded_body)
+        end
+      end
+    end
+
+    test_record_and_playback "with spaces encoded as +",           "q=a+b"
+    test_record_and_playback "with spaces encoded as %20",         "q=a%20b"
+    test_record_and_playback "with a complex escaped query param", "q=#{CGI.escape("A&(! 234k !@ kasdj232\#$ kjw35")}"
+
+    it 'plays back an empty body response exactly as it was recorded (e.g. nil vs empty string)' do
+      pending "awaiting an external fix", :if => library.gsub('_', '/').include?('net/http') && library_hook_name != :webmock do
+        get_body = lambda do
+          VCR.use_cassette('empty_body', :record => :once) do
+            get_body_object make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/204")
+          end
+        end
+
+        recorded = get_body.call
+        played_back = get_body.call
+        expect(played_back).to eq(recorded)
+      end
+    end
+
+    describe 'making an HTTP request' do
+      let(:status)        { VCR::ResponseStatus.new(200, 'OK') }
+      let(:interaction)   { VCR::HTTPInteraction.new(request, response) }
+      let(:response_body) { "The response body" }
+
+      before(:each) do
+        stub_requests([interaction], [:method, :uri])
+      end
+
+      context "when the the stubbed request and response has no headers" do
+        let(:request)  { VCR::Request.new(:get, 'http://example.com:80/') }
+        let(:response) { VCR::Response.new(status, nil, response_body, '1.1') }
+
+        it 'returns the response for a matching request' do
+          expect(get_body_string(make_http_request(:get, 'http://example.com/'))).to eq(response_body)
+        end
+      end
+
+      def self.test_playback(description, url)
+        context "when a URL #{description} has been stubbed" do
+          let(:request)     { VCR::Request.new(:get, url) }
+          let(:response)    { VCR::Response.new(status, nil, response_body, '1.1') }
+
+          it 'returns the expected response for the same request' do
+            expect(get_body_string(make_http_request(:get, url))).to eq(response_body)
+          end
+        end
+      end
+
+      test_playback "using https and no explicit port", "https://example.com/foo"
+      test_playback "using https and port 443",         "https://example.com:443/foo"
+      test_playback "using https and some other port",  "https://example.com:5190/foo"
+      test_playback "that has query params",            "http://example.com/search?q=param"
+      test_playback "with an encoded ampersand",        "http://example.com:80/search?q=#{CGI.escape("Q&A")}"
+    end
+
+    it 'does not query the http interaction list excessively' do
+      call_count = 0
+      [:has_interaction_matching?, :response_for].each do |method_name|
+        orig_meth = VCR.http_interactions.method(method_name)
+        allow(VCR.http_interactions).to receive(method_name) do |*args|
+          call_count += 1
+          orig_meth.call(*args)
+        end
+      end
+
+      VCR.insert_cassette('foo')
+      make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/foo")
+
+      expect(call_count).to eq(1)
+    end
+
+    describe "using the library's stubbing/disconnection APIs" do
+      let!(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
+
+      if method_defined?(:disable_real_connections)
+        it 'can make a real request when VCR is turned off' do
+          enable_real_connections
+          VCR.turn_off!
+          expect(get_body_string(make_http_request(:get, request_url))).to eq("FOO!")
+        end
+
+        it 'does not mess with VCR when real connections are disabled' do
+          VCR.insert_cassette('example')
+          disable_real_connections
+
+          expect(VCR).to receive(:record_http_interaction) do |interaction|
+            expect(interaction.request.uri).to eq(request_url)
+          end
+
+          make_http_request(:get, request_url)
+        end
+
+        it 'can disable real connections when VCR is turned off' do
+          VCR.turn_off!
+          expected_error = disable_real_connections
+
+          expect {
+            make_http_request(:get, request_url)
+          }.to raise_error(expected_error)
+        end
+      end
+
+      if method_defined?(:directly_stub_request)
+        it 'can directly stub the request when VCR is turned off' do
+          VCR.turn_off!
+          directly_stub_request(:get, request_url, "stubbed response")
+          expect(get_body_string(make_http_request(:get, request_url))).to eq("stubbed response")
+        end
+
+        it 'can directly stub the request when VCR is turned on and no cassette is in use' do
+          directly_stub_request(:get, request_url, "stubbed response")
+          expect(get_body_string(make_http_request(:get, request_url))).to eq("stubbed response")
+        end
+
+        it 'can directly stub the request when VCR is turned on and a cassette is in use' do
+          VCR.use_cassette("temp") do
+            directly_stub_request(:get, request_url, "stubbed response")
+            expect(get_body_string(make_http_request(:get, request_url))).to eq("stubbed response")
+          end
+        end
+
+        it 'does not record requests that are directly stubbed' do
+          expect(VCR).to respond_to(:record_http_interaction)
+          expect(VCR).not_to receive(:record_http_interaction)
+
+          VCR.use_cassette("temp") do
+            directly_stub_request(:get, request_url, "stubbed response")
+            expect(get_body_string(make_http_request(:get, request_url))).to eq("stubbed response")
+          end
+        end
+      end
+    end
+
+    describe "request hooks" do
+      context 'when there is an around_http_request hook' do
+        let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
+
+        it 'yields the request to the block' do
+          yielded_request = nil
+          VCR.configuration.around_http_request do |request|
+            yielded_request = request
+            request.proceed
+          end
+
+          VCR.use_cassette('new_cassette') do
+            make_http_request(:get, request_url)
+          end
+
+          expect(yielded_request.method).to eq(:get)
+          expect(yielded_request.uri).to eq(request_url)
+        end
+
+        it 'returns the response from request.proceed' do
+          response = nil
+          VCR.configuration.around_http_request do |request|
+            response = request.proceed
+          end
+
+          VCR.use_cassette('new_cassette') do
+            make_http_request(:get, request_url)
+          end
+
+          expect(response.body).to eq("FOO!")
+        end
+
+        it 'can be used to use a cassette for a request' do
+          VCR.configuration.around_http_request do |request|
+            VCR.use_cassette('new_cassette', &request)
+          end
+
+          expect(VCR).to receive(:record_http_interaction) do
+            expect(VCR.current_cassette.name).to eq('new_cassette')
+          end
+
+          expect(VCR.current_cassette).to be_nil
+          make_http_request(:get, request_url)
+          expect(VCR.current_cassette).to be_nil
+        end
+
+        it 'nests them inside each other, making the first declared hook the outermost' do
+          order = []
+
+          VCR.configure do |c|
+            c.ignore_request { |r| true }
+            c.around_http_request do |request|
+              order << :before_1
+              request.proceed
+              order << :after_1
+            end
+
+            c.around_http_request do |request|
+              order << :before_2
+              request.proceed
+              order << :after_2
+            end
+          end
+
+          make_http_request(:get, request_url)
+
+          expect(order).to eq([:before_1, :before_2, :after_2, :after_1])
+        end
+
+        it 'raises an appropriate error if the hook does not call request.proceed' do
+          VCR.configuration.ignore_request { |r| true }
+          hook_declaration = "#{__FILE__}:#{__LINE__ + 1}"
+          VCR.configuration.around_http_request { |r| }
+
+          expect {
+            make_http_request(:get, request_url)
+          }.to raise_error { |error|
+            expect(error.message).to include('must call #proceed on the yielded request')
+            expect(error.message).to include(hook_declaration)
+          }
+        end
+
+        it 'does not get a dead fiber error when multiple requests are made' do
+          VCR.configuration.around_http_request do |request|
+            VCR.use_cassette('new_cassette', &request)
+          end
+
+          3.times { make_http_request(:get, request_url) }
+        end
+
+        it 'allows the hook to be filtered' do
+          order = []
+          VCR.configure do |c|
+            c.ignore_request { |r| true }
+            c.around_http_request(lambda { |r| r.uri =~ /foo/}) do |request|
+              order << :before_foo
+              request.proceed
+              order << :after_foo
+            end
+
+            c.around_http_request(lambda { |r| r.uri !~ /foo/}) do |request|
+              order << :before_not_foo
+              request.proceed
+              order << :after_not_foo
+            end
+          end
+
+          make_http_request(:get, request_url)
+          expect(order).to eq([:before_foo, :after_foo])
+        end
+
+        it 'ensures that both around/before are invoked or neither' do
+          order = []
+          allow_1, allow_2 = false, true
+          VCR.configure do |c|
+            c.ignore_request { |r| true }
+            c.around_http_request(lambda { |r| allow_1 = !allow_1 }) do |request|
+              order << :before_1
+              request.proceed
+              order << :after_1
+            end
+
+            c.around_http_request(lambda { |r| allow_2 = !allow_2 }) do |request|
+              order << :before_2
+              request.proceed
+              order << :after_2
+            end
+          end
+
+          make_http_request(:get, request_url)
+          expect(order).to eq([:before_1, :after_1])
+        end
+      end if RUBY_VERSION >= '1.9'
+
+      it 'correctly assigns the correct type to both before and after request hooks, even if they are different' do
+        before_type = after_type = nil
+        VCR.configuration.before_http_request do |request|
+          before_type = request.type
+          VCR.insert_cassette('example')
+        end
+
+        VCR.configuration.after_http_request do |request|
+          after_type = request.type
+          VCR.eject_cassette
+        end
+
+        make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/foo")
+        expect(before_type).to be(:unhandled)
+        expect(after_type).to be(:recordable)
+      end
+
+      context "when the request is ignored" do
+        before(:each) do
+          VCR.configuration.ignore_request { |r| true }
+        end
+
+        it_behaves_like "request hooks", library_hook_name, :ignored
+      end
+
+      context "when the request is directly stubbed" do
+        before(:each) do
+          directly_stub_request(:get, request_url, "FOO!")
+        end
+
+        it_behaves_like "request hooks", library_hook_name, :externally_stubbed
+      end if method_defined?(:directly_stub_request)
+
+      context 'when the request is recorded' do
+        let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
+
+        it_behaves_like "request hooks", library_hook_name, :recordable do
+          let(:string_in_cassette) { 'example.com get response 1 with path=foo' }
+
+          it 'plays back the cassette when a request is made' do
+            VCR.eject_cassette
+            VCR.configure do |c|
+              c.cassette_library_dir = File.join(VCR::SPEC_ROOT, 'fixtures')
+              c.before_http_request do |request|
+                VCR.insert_cassette('fake_example_responses', :record => :none)
+              end
+            end
+            expect(get_body_string(make_http_request(:get, 'http://example.com/foo'))).to eq(string_in_cassette)
+          end
+
+          specify 'the after_http_request hook can be used to eject a cassette after the request is recorded' do
+            VCR.configuration.after_http_request { |request| VCR.eject_cassette }
+
+            expect(VCR).to receive(:record_http_interaction) do |interaction|
+              expect(VCR.current_cassette).to be(inserted_cassette)
+            end
+
+            make_request
+            expect(VCR.current_cassette).to be_nil
+          end
+        end
+      end
+
+      context 'when a stubbed response is played back for the request' do
+        before(:each) do
+          stub_requests([http_interaction(request_url)], [:method, :uri])
+        end
+
+        it_behaves_like "request hooks", library_hook_name, :stubbed_by_vcr
+      end
+
+      context 'when the request is not allowed' do
+        it_behaves_like "request hooks", library_hook_name, :unhandled do
+          undef assert_expected_response
+          def assert_expected_response(response)
+            expect(response).to be_nil
+          end
+
+          undef make_request
+          def make_request(disabled = false)
+            if disabled
+              make_http_request(:get, request_url)
+            else
+              expect { make_http_request(:get, request_url) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+            end
+          end
+        end
+      end
+    end
+
+    describe '.stub_requests using specific match_attributes' do
+      before(:each) { allow(VCR).to receive(:real_http_connections_allowed?).and_return(false) }
+      let(:interactions) { interactions_from('match_requests_on.yml') }
+
+      let(:normalized_interactions) do
+        interactions.each do |i|
+          i.request.headers = normalize_request_headers(i.request.headers)
+        end
+        interactions
+      end
+
+      def self.matching_on(attribute, valid, invalid, &block)
+        describe ":#{attribute}" do
+          let(:perform_stubbing) { stub_requests(normalized_interactions, [attribute]) }
+
+          before(:each) { perform_stubbing }
+          module_eval(&block)
+
+          valid.each do |val, response|
+            it "returns the expected response for a #{val.inspect} request" do
+              expect(get_body_string(make_http_request(val))).to eq(response)
+            end
+          end
+
+          it "raises an error for a request with a different #{attribute}" do
+            expect { make_http_request(invalid) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+          end
+        end
+      end
+
+      matching_on :method, { :get => "get method response", :post => "post method response" }, :put do
+        def make_http_request(http_method)
+          make_request(http_method, 'http://some-wrong-domain.com/', nil, {})
+        end
+      end
+
+      matching_on :host, { 'example1.com' => 'example1.com host response', 'example2.com' => 'example2.com host response' }, 'example3.com' do
+        def make_http_request(host)
+          make_request(:get, "http://#{host}/some/wrong/path", nil, {})
+        end
+      end
+
+      matching_on :path, { '/path1' => 'path1 response', '/path2' => 'path2 response' }, '/path3' do
+        def make_http_request(path)
+          make_request(:get, "http://some.wrong.domain.com#{path}?p=q", nil, {})
+        end
+      end
+
+      matching_on :uri, { 'http://example.com/uri1' => 'uri1 response', 'http://example.com/uri2' => 'uri2 response' }, 'http://example.com/uri3' do
+        def make_http_request(uri)
+          make_request(:get, uri, nil, {})
+        end
+      end
+
+      matching_on :body, { 'param=val1' => 'val1 body response', 'param=val2' => 'val2 body response' }, 'param=val3' do
+        def make_http_request(body)
+          make_request(:put, "http://wrong-domain.com/wrong/path", body, {})
+        end
+      end
+
+      matching_on :headers, {{ 'X-Http-Header1' => 'val1' } => 'val1 header response', { 'X-Http-Header1' => 'val2' } => 'val2 header response' }, { 'X-Http-Header1' => 'val3' } do
+        def make_http_request(headers)
+          make_request(:get, "http://wrong-domain.com/wrong/path", nil, headers)
+        end
+      end
+    end
+
+    def self.test_real_http_request(http_allowed, *other)
+      let(:url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
+
+      if http_allowed
+
+        it 'allows real http requests' do
+          expect(get_body_string(make_http_request(:get, url))).to eq('FOO!')
+        end
+
+        describe 'recording new http requests' do
+          let(:recorded_interaction) do
+            interaction = nil
+            expect(VCR).to receive(:record_http_interaction) { |i| interaction = i }
+            make_http_request(:post, url, "the body", { 'X-Http-Foo' => 'bar' })
+            interaction
+          end
+
+          it 'does not record the request if the hook is disabled' do
+            VCR.library_hooks.exclusively_enabled :something_else do
+              expect(VCR).not_to receive(:record_http_interaction)
+              make_http_request(:get, url)
+            end
+          end
+
+          it 'records the request uri' do
+            expect(recorded_interaction.request.uri).to eq(url)
+          end
+
+          it 'records the request method' do
+            expect(recorded_interaction.request.method).to eq(:post)
+          end
+
+          it 'records the request body' do
+            expect(recorded_interaction.request.body).to eq("the body")
+          end
+
+          it 'records the request headers' do
+            headers = downcase_headers(recorded_interaction.request.headers)
+            expect(headers).to include('x-http-foo' => ['bar'])
+          end
+
+          it 'records the response status code' do
+            expect(recorded_interaction.response.status.code).to eq(200)
+          end
+
+          it 'records the response status message' do
+            expect(recorded_interaction.response.status.message.strip).to eq('OK')
+          end unless other.include?(:status_message_not_exposed)
+
+          it 'records the response body' do
+            expect(recorded_interaction.response.body).to eq('FOO!')
+          end
+
+          it 'records the response headers' do
+            headers = downcase_headers(recorded_interaction.response.headers)
+            expect(headers).to include('content-type' => ["text/html;charset=utf-8"])
+          end
+        end
+      else
+        it 'does not allow real HTTP requests or record them' do
+          expect(VCR).to receive(:record_http_interaction).never
+          expect { make_http_request(:get, url) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+        end
+      end
+    end
+
+    [true, false].each do |http_allowed|
+      context "when VCR.real_http_connections_allowed? is returning #{http_allowed}" do
+        before(:each) { allow(VCR).to receive(:real_http_connections_allowed?).and_return(http_allowed) }
+
+        test_real_http_request(http_allowed, *other)
+
+        unless http_allowed
+          localhost_response = "Localhost response"
+
+          context 'when ignore_hosts is configured to "127.0.0.1", "localhost"' do
+            before(:each) do
+              VCR.configure { |c| c.ignore_hosts "127.0.0.1", "localhost" }
+            end
+
+            %w[ 127.0.0.1 localhost ].each do |localhost_alias|
+              it "allows requests to #{localhost_alias}" do
+                expect(get_body_string(make_http_request(:get, "http://#{localhost_alias}:#{VCR::SinatraApp.port}/localhost_test"))).to eq(localhost_response)
+              end
+            end
+
+            it 'does not allow requests to 0.0.0.0' do
+              expect { make_http_request(:get, "http://0.0.0.0:#{VCR::SinatraApp.port}/localhost_test") }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
+            end
+          end
+        end
+
+        context 'when some requests are stubbed' do
+          let(:interactions) { interactions_from('fake_example_responses.yml') }
+          before(:each) do
+            stub_requests(interactions, VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
+          end
+
+          it 'gets the stubbed responses when requests are made to http://example.com/foo, and does not record them' do
+            expect(VCR).to receive(:record_http_interaction).never
+            expect(get_body_string(make_http_request(:get, 'http://example.com/foo'))).to match(/example\.com get response \d with path=foo/)
+          end
+
+          it 'rotates through multiple responses for the same request' do
+            expect(get_body_string(make_http_request(:get, 'http://example.com/foo'))).to eq('example.com get response 1 with path=foo')
+            expect(get_body_string(make_http_request(:get, 'http://example.com/foo'))).to eq('example.com get response 2 with path=foo')
+          end unless other.include?(:does_not_support_rotating_responses)
+
+          it "correctly handles stubbing multiple values for the same header" do
+            header = get_header('Set-Cookie', make_http_request(:get, 'http://example.com/two_set_cookie_headers'))
+            header = header.split(', ') if header.respond_to?(:split)
+            expect(header).to match_array ['bar=bazz', 'foo=bar']
+          end
+        end
+      end
+    end
+  end
+end