vcr 1.11.3 → 2.0.0.beta1

data/spec/monkey_patches.rb

@@ -1,26 +1,36 @@
+require 'typhoeus' if RUBY_INTERPRETER == :mri
+
 module MonkeyPatches
   extend self
 
   NET_HTTP_SINGLETON = class << Net::HTTP; self; end
 
-  MONKEY_PATCHES = [
+  NET_HTTP_MONKEY_PATCHES = [
     [Net::BufferedIO,    :initialize],
     [Net::HTTP,          :request],
     [Net::HTTP,          :connect],
     [NET_HTTP_SINGLETON, :socket_type]
   ]
 
+  ALL_MONKEY_PATCHES = NET_HTTP_MONKEY_PATCHES.dup
+
+  ALL_MONKEY_PATCHES << [Typhoeus::Hydra::Stubbing::SharedMethods, :find_stub_from_request] if RUBY_INTERPRETER == :mri
+
   def enable!(scope)
     case scope
       when :fakeweb
-        realias_all :with_fakeweb
-        enable!(:vcr) # fakeweb adapter relies upon VCR's Net::HTTP monkey patch
+        realias_net_http :with_fakeweb
+        enable!(:vcr) # fakeweb hook relies upon VCR's Net::HTTP monkey patch
       when :webmock
+        ::WebMock.reset!
         ::WebMock::HttpLibAdapters::NetHttpAdapter.enable!
-        ::WebMock::HttpLibAdapters::TyphoeusAdapter.enable! unless RUBY_INTERPRETER == :jruby
+        ::WebMock::HttpLibAdapters::TyphoeusAdapter.enable! if RUBY_INTERPRETER == :mri
         $original_webmock_callbacks.each do |cb|
           ::WebMock::CallbackRegistry.add_callback(cb[:options], cb[:block])
         end
+      when :typhoeus
+        Typhoeus::Hydra.global_hooks = $original_typhoeus_hooks
+        realias Typhoeus::Hydra::Stubbing::SharedMethods, :find_stub_from_request, :with_vcr
       when :vcr
         realias Net::HTTP, :request, :with_vcr
       else raise ArgumentError.new("Unexpected scope: #{scope}")
@@ -34,12 +44,17 @@ module MonkeyPatches
       ::WebMock::HttpLibAdapters::NetHttpAdapter.disable!
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.disable! unless RUBY_INTERPRETER == :jruby
       ::WebMock::CallbackRegistry.reset
+      ::WebMock::StubRegistry.instance.request_stubs = []
+    end
+
+    if defined?(::Typhoeus)
+      Typhoeus::Hydra.clear_global_hooks
     end
   end
 
   def init
     # capture the monkey patched definitions so we can realias to them in the future
-    MONKEY_PATCHES.each do |mp|
+    ALL_MONKEY_PATCHES.each do |mp|
       capture_method_definition(mp.first, mp.last, false)
     end
   end
@@ -68,7 +83,7 @@ module MonkeyPatches
 
   # capture the original method definitions before the monkey patches have been defined
   # so we can realias to the originals in the future
-  MONKEY_PATCHES.each do |mp|
+  ALL_MONKEY_PATCHES.each do |mp|
     capture_method_definition(mp.first, mp.last, true)
   end
 
@@ -81,7 +96,13 @@ module MonkeyPatches
   end
 
   def realias_all(alias_extension)
-    MONKEY_PATCHES.each do |mp|
+    ALL_MONKEY_PATCHES.each do |mp|
+      realias mp.first, mp.last, alias_extension
+    end
+  end
+
+  def realias_net_http(alias_extension)
+    NET_HTTP_MONKEY_PATCHES.each do |mp|
       realias mp.first, mp.last, alias_extension
     end
   end
@@ -95,10 +116,17 @@ if RUBY_INTERPRETER == :mri
   require 'patron'
   require 'em-http-request'
   require 'curb'
-  require 'typhoeus'
+
+  require 'vcr/library_hooks/typhoeus'
+  $original_typhoeus_hooks = Typhoeus::Hydra.global_hooks.dup
+
+  # define an alias that we can re-alias to in the future
+  Typhoeus::Hydra::Stubbing::SharedMethods.class_eval do
+    alias find_stub_from_request_with_vcr find_stub_from_request
+  end
 end
 
-require 'vcr/http_stubbing_adapters/fakeweb'
+require 'vcr/library_hooks/fakeweb'
 
 # All Net::HTTP monkey patches have now been loaded, so capture the
 # appropriate method definitions so we can disable them later.
@@ -108,16 +136,17 @@ MonkeyPatches.init
 # subclasses Net::HTTP and inherits them...
 MonkeyPatches.disable_all!
 
-require 'vcr/http_stubbing_adapters/webmock'
+require 'vcr/library_hooks/webmock'
 $original_webmock_callbacks = ::WebMock::CallbackRegistry.callbacks
 
 # disable all by default; we'll enable specific ones when we need them
 MonkeyPatches.disable_all!
 
 RSpec.configure do |config|
-  [:fakeweb, :webmock, :vcr].each do |scope|
+  [:fakeweb, :webmock, :vcr, :typhoeus].each do |scope|
     config.before(:all, :with_monkey_patches => scope) { MonkeyPatches.enable!(scope) }
     config.after(:all,  :with_monkey_patches => scope) { MonkeyPatches.disable_all!   }
   end
 end
 
+require 'vcr/library_hooks/excon'

data/spec/spec_helper.rb

@@ -8,9 +8,6 @@ end
 
 require 'rspec'
 
-# Ruby 1.9.1 has a different yaml serialization format.
-YAML_SERIALIZATION_VERSION = RUBY_VERSION == '1.9.1' ? '1.9.1' : 'not_1.9.1'
-
 Dir['./spec/support/**/*.rb'].each { |f| require f }
 
 require 'vcr'
@@ -19,55 +16,27 @@ require 'monkey_patches'
 module VCR
   SPEC_ROOT = File.dirname(__FILE__)
 
-  module Config
-    def reset!(stubbing_lib = :fakeweb)
-      self.default_cassette_options = { :record => :new_episodes }
-
-      if stubbing_lib
-        stub_with stubbing_lib
-      else
-        http_stubbing_libraries.clear
-      end
-
-      clear_hooks
-      @ignored_hosts = []
-
-      VCR.instance_eval do
-        instance_variables.each { |ivar| remove_instance_variable(ivar) }
-      end
-      VCR.send(:initialize_ivars)
+  def reset!(hook = :fakeweb)
+    instance_variables.each do |ivar|
+      instance_variable_set(ivar, nil)
     end
+    configuration.hook_into hook if hook
   end
 end
 
 RSpec.configure do |config|
   config.color_enabled = true
-  config.debug = (using_git && RUBY_INTERPRETER == :mri && !%w[ 1.9.1 1.9.3 ].include?(RUBY_VERSION) && !ENV['CI'])
+  config.debug = (using_git && RUBY_INTERPRETER == :mri && !%w[ 1.9.3 ].include?(RUBY_VERSION) && !ENV['CI'])
   config.treat_symbols_as_metadata_keys_with_true_values = true
 
   tmp_dir = File.expand_path('../../tmp/cassette_library_dir', __FILE__)
   config.before(:each) do
-    VCR::Config.cassette_library_dir = tmp_dir
-    VCR.turn_on! unless VCR.turned_on?
-    VCR.eject_cassette while VCR.current_cassette
-
-    VCR::Config.reset!
-
-    WebMock.allow_net_connect!
-    WebMock.reset!
-
-    FakeWeb.allow_net_connect = true
-    FakeWeb.clean_registry
-
-    VCR::HttpStubbingAdapters::Faraday.reset!
-    VCR::HttpStubbingAdapters::Excon.reset!
+    VCR.reset!
+    VCR.configuration.cassette_library_dir = tmp_dir
   end
 
   config.after(:each) do
     FileUtils.rm_rf tmp_dir
-    VCR::HttpStubbingAdapters::Common.adapters.each do |a|
-      a.ignored_hosts = []
-    end
   end
 
   config.before(:all, :disable_warnings => true) do
@@ -85,8 +54,3 @@ RSpec.configure do |config|
   config.alias_it_should_behave_like_to :it_performs, 'it performs'
 end
 
-http_stubbing_dir = File.join(File.dirname(__FILE__), '..', 'lib', 'vcr', 'http_stubbing_adapters')
-Dir[File.join(http_stubbing_dir, '*.rb')].each do |file|
-  next if RUBY_INTERPRETER != :mri && file =~ /(typhoeus)/
-  require "vcr/http_stubbing_adapters/#{File.basename(file)}"
-end

data/spec/support/http_library_adapters.rb

@@ -137,7 +137,7 @@ HTTP_LIBRARY_ADAPTERS['excon'] = Module.new do
 end
 
 %w[ net_http typhoeus patron ].each do |_faraday_adapter|
-  HTTP_LIBRARY_ADAPTERS["faraday-#{_faraday_adapter}"] = Module.new do
+  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})"
@@ -175,20 +175,10 @@ end
 
     def faraday_connection(url_root)
       Faraday::Connection.new(:url => url_root) do |builder|
-        builder.use VCR::Middleware::Faraday do |cassette|
-          cassette.name    'faraday_example'
-
-          if respond_to?(:match_requests_on)
-            cassette.options :match_requests_on => match_requests_on
-          end
-
-          if respond_to?(:record_mode)
-            cassette.options :record => record_mode
-          end
-        end
-
+        builder.use     VCR::Middleware::Faraday
         builder.adapter faraday_adapter
       end
     end
   end
 end
+

data/spec/support/shared_example_groups/{http_library.rb → hook_into_http_library.rb}

@@ -2,22 +2,20 @@ require 'cgi'
 
 NET_CONNECT_NOT_ALLOWED_ERROR = /You can use VCR to automatically record this request and replay it later/
 
-shared_examples_for "an http library" do |library, supported_request_match_attributes, *other|
+shared_examples_for "a hook into an HTTP library" do |library, *other|
   unless adapter_module = HTTP_LIBRARY_ADAPTERS[library]
     raise ArgumentError.new("No http library adapter module could be found for #{library}")
   end
 
-  http_lib_unsupported = if RUBY_INTERPRETER == :mri
-    # em-http-request is causing issues on 1.8.6 on travis like:
-    # ruby: symbol lookup error: /home/travis/.rvm/gems/ruby-1.8.6-p420/gems/em-http-request-0.3.0/lib/http11_client.so: undefined symbol: rb_hash_lookup
-    library =~ /em-http/ && RUBY_VERSION == '1.8.6' && ENV['TRAVIS']
-  else
-    library =~ /(typhoeus|curb|patron|em-http)/
-  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
 
+    def stub_requests(*args)
+      VCR.stub(:http_interactions => VCR::Cassette::HTTPInteractionList.new(*args))
+    end
+
     # 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
@@ -60,11 +58,9 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
       let(:status)        { VCR::ResponseStatus.new(200, 'OK') }
       let(:interaction)   { VCR::HTTPInteraction.new(request, response) }
       let(:response_body) { "The response body" }
-      let(:match_requests_on) { [:method, :uri] }
-      let(:record_mode) { :none }
 
       before(:each) do
-        subject.stub_requests([interaction], match_requests_on)
+        stub_requests([interaction], [:method, :uri])
       end
 
       context "when the the stubbed request and response has no headers" do
@@ -98,35 +94,24 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
     end
 
     describe '.stub_requests using specific match_attributes' do
-      before(:each) { subject.http_connections_allowed = false }
-      let(:interactions) { VCR::YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', YAML_SERIALIZATION_VERSION, 'match_requests_on.yml')) }
+      before(:each) { VCR.stub(:real_http_connections_allowed? => false) }
+      let(:interactions) { VCR::YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', 'match_requests_on.yml')) }
 
-      @supported_request_match_attributes = supported_request_match_attributes
       def self.matching_on(attribute, valid, invalid, &block)
-        supported_request_match_attributes = @supported_request_match_attributes
-
         describe ":#{attribute}" do
-          let(:perform_stubbing) { subject.stub_requests(interactions, match_requests_on) }
-          let(:match_requests_on) { [attribute] }
-          let(:record_mode) { :none }
+          let(:perform_stubbing) { stub_requests(interactions, [attribute]) }
 
-          if supported_request_match_attributes.include?(attribute)
-            before(:each) { perform_stubbing }
-            module_eval(&block)
+          before(:each) { perform_stubbing }
+          module_eval(&block)
 
-            valid.each do |val, response|
-              it "returns the expected response for a #{val.inspect} request" do
-                get_body_string(make_http_request(val)).should eq(response)
-              end
+          valid.each do |val, response|
+            it "returns the expected response for a #{val.inspect} request" do
+              get_body_string(make_http_request(val)).should 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
-          else
-            it 'raises an error indicating matching requests on this attribute is not supported' do
-              expect { perform_stubbing }.to raise_error(/does not support matching requests on #{attribute}/)
-            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
@@ -185,11 +170,12 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
             interaction
           end
 
-          it 'does not record the request if the adapter is disabled' do
-            subject.stub(:enabled?).and_return(false)
-            VCR.should_not_receive(:record_http_interaction)
-            make_http_request(:get, url)
-          end
+          it 'does not record the request if the hook is disabled' do
+            VCR.library_hooks.exclusively_enabled :something_else do
+              VCR.should_not_receive(:record_http_interaction)
+              make_http_request(:get, url)
+            end
+          end unless other.include?(:not_disableable)
 
           it 'records the request uri' do
             recorded_interaction.request.uri.should eq(url)
@@ -224,8 +210,6 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
           end
         end
       else
-        let(:record_mode) { :none }
-
         it 'does not allow real HTTP requests or record them' do
           VCR.should_receive(:record_http_interaction).never
           expect { make_http_request(:get, url) }.to raise_error(NET_CONNECT_NOT_ALLOWED_ERROR)
@@ -233,74 +217,36 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
       end
     end
 
-    def test_request_stubbed(method, url, expected)
-      subject.request_stubbed?(VCR::Request.new(method, url), [:method, :uri]).should eq(expected)
-    end
-
-    it "returns false from #http_connections_allowed? when http_connections_allowed is set to nil" do
-      subject.http_connections_allowed = nil
-      subject.http_connections_allowed?.should eq(false)
-    end
-
-    describe '.restore_stubs_checkpoint' do
-      it 'raises an appropriate error when there is no matching checkpoint' do
-        expect {
-          subject.restore_stubs_checkpoint(:some_crazy_checkpoint_that_doesnt_exist)
-        }.to raise_error(ArgumentError, /no checkpoint .* could be found/i)
-      end
-    end
-
     [true, false].each do |http_allowed|
-      context "when http_connections_allowed is set to #{http_allowed}" do
-        before(:each) { subject.http_connections_allowed = http_allowed }
-
-        it "returns #{http_allowed} for #http_connections_allowed?" do
-          subject.http_connections_allowed?.should eq(http_allowed)
-        end
+      context "when VCR.real_http_connections_allowed? is returning #{http_allowed}" do
+        before(:each) { VCR.stub(:real_http_connections_allowed? => http_allowed) }
 
         test_real_http_request(http_allowed, *other)
 
         unless http_allowed
           localhost_response = "Localhost response"
 
-          describe '.ignore_hosts' do
-            let(:record_mode) { :none }
-
-            context 'when set to ["127.0.0.1", "localhost"]' do
-              before(:each) do
-                subject.ignored_hosts = ["127.0.0.1", "localhost"]
-              end
+          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
-                  get_body_string(make_http_request(:get, "http://#{localhost_alias}:#{VCR::SinatraApp.port}/localhost_test")).should eq(localhost_response)
-                end
+            %w[ 127.0.0.1 localhost ].each do |localhost_alias|
+              it "allows requests to #{localhost_alias}" do
+                get_body_string(make_http_request(:get, "http://#{localhost_alias}:#{VCR::SinatraApp.port}/localhost_test")).should 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
+            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, after setting a checkpoint' do
+        context 'when some requests are stubbed' do
           before(:each) do
-            subject.create_stubs_checkpoint(:my_checkpoint)
-            @recorded_interactions = VCR::YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', YAML_SERIALIZATION_VERSION, 'fake_example.com_responses.yml'))
-            subject.stub_requests(@recorded_interactions, VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES)
-          end
-
-          if other.include?(:needs_net_http_extension)
-            it 'returns true from #request_stubbed? for the requests that are stubbed' do
-              test_request_stubbed(:post, 'http://example.com', true)
-              test_request_stubbed(:get, 'http://example.com/foo', true)
-            end
-
-            it 'returns false from #request_stubbed? for requests that are not stubbed' do
-              test_request_stubbed(:post, 'http://example.com/foo', false)
-              test_request_stubbed(:get, 'http://google.com', false)
-            end
+            @recorded_interactions = VCR::YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', 'fake_example.com_responses.yml'))
+            stub_requests(@recorded_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
@@ -311,10 +257,6 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
           it 'rotates through multiple responses for the same request' do
             get_body_string(make_http_request(:get, 'http://example.com/foo')).should eq('example.com get response 1 with path=foo')
             get_body_string(make_http_request(:get, 'http://example.com/foo')).should eq('example.com get response 2 with path=foo')
-
-            # subsequent requests keep getting the last one
-            get_body_string(make_http_request(:get, 'http://example.com/foo')).should eq('example.com get response 2 with path=foo')
-            get_body_string(make_http_request(:get, 'http://example.com/foo')).should 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
@@ -322,20 +264,6 @@ shared_examples_for "an http library" do |library, supported_request_match_attri
             header = header.split(', ') if header.respond_to?(:split)
             header.should =~ ['bar=bazz', 'foo=bar']
           end
-
-          context 'when we restore our previous check point' do
-            before(:each) { subject.restore_stubs_checkpoint(:my_checkpoint) }
-
-            test_real_http_request(http_allowed, *other)
-
-            if other.include?(:needs_net_http_extension)
-              it 'returns false from #request_stubbed?' do
-                test_request_stubbed(:get, 'http://example.com/foo', false)
-                test_request_stubbed(:post, 'http://example.com', false)
-                test_request_stubbed(:get, 'http://google.com', false)
-              end
-            end
-          end
         end
       end
     end