RubyGems - social_url_stats - Versions diffs - 0.0.1 → 0.0.2 - Mend

social_url_stats 0.0.1 → 0.0.2

Files changed (826) hide show

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

@@ -1,8 +0,0 @@
-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 DELETED

@@ -1,10 +0,0 @@
-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 DELETED

@@ -1,285 +0,0 @@
-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 DELETED

@@ -1,31 +0,0 @@
-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 DELETED

@@ -1,7 +0,0 @@
-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 DELETED

@@ -1,63 +0,0 @@
-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 DELETED

@@ -1,594 +0,0 @@
-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