vcr 2.0.0.beta2 → 2.0.0.rc1

data/lib/vcr/util/version_checker.rb

@@ -42,8 +42,10 @@ module VCR
       case
         when @major < @min_major then :too_low
         when @major > @max_major then :too_high
+        when @major > @min_major then :ok
         when @minor < @min_minor then :too_low
         when @minor > @max_minor then :too_high
+        when @minor > @min_minor then :ok
         when @patch < @min_patch then :too_low
       end
     end

data/lib/vcr/version.rb

@@ -3,7 +3,7 @@ module VCR
 
   def version
     @version ||= begin
-      string = '2.0.0.beta2'
+      string = '2.0.0.rc1'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/spec/fixtures/cassette_spec/example.yml

@@ -108,4 +108,4 @@ http_interactions:
     body: Another example.com response
     http_version: '1.1'
   recorded_at: Tue, 01 Nov 2011 04:49:54 GMT
-recorded_with: VCR 1.11.3
+recorded_with: VCR 2.0.0

data/spec/monkey_patches.rb

@@ -40,7 +40,7 @@ module MonkeyPatches
   def disable_all!
     realias_all :without_monkeypatches
 
-    if defined?(::WebMock)
+    if defined?(::WebMock::HttpLibAdapters)
       ::WebMock::HttpLibAdapters::NetHttpAdapter.disable!
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.disable! if defined?(::Typhoeus)
       ::WebMock::CallbackRegistry.reset

data/spec/spec_helper.rb

@@ -25,12 +25,13 @@ module VCR
 end
 
 RSpec.configure do |config|
+  config.order = :rand
   config.color_enabled = true
   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
+  config.before(:each, :skip_vcr_reset => lambda { |v| v != true }) do
     VCR.reset!
     VCR.configuration.cassette_library_dir = tmp_dir
   end
@@ -54,3 +55,4 @@ RSpec.configure do |config|
   config.alias_it_should_behave_like_to :it_performs, 'it performs'
 end
 
+VCR::SinatraApp.boot

data/spec/support/http_library_adapters.rb

@@ -156,7 +156,7 @@ HTTP_LIBRARY_ADAPTERS['typhoeus'] = Module.new do
   end
 
   def normalize_request_headers(headers)
-    headers.merge("User-Agent" => ["Typhoeus - http://github.com/dbalatero/typhoeus/tree/master"])
+    headers
   end
 end
 
@@ -172,7 +172,9 @@ HTTP_LIBRARY_ADAPTERS['excon'] = Module.new do
   end
 
   def make_http_request(method, url, body = nil, headers = {})
-    Excon.send(method, url, :body => body, :headers => 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::Connection.new(url).request(:method => method.to_s.upcase, :body => body, :headers => headers)
   end
 
   def normalize_request_headers(headers)
@@ -219,7 +221,6 @@ end
 
     def faraday_connection(url_root)
       Faraday::Connection.new(:url => url_root) do |builder|
-        builder.use     VCR::Middleware::Faraday
         builder.adapter faraday_adapter
       end
     end

data/spec/support/shared_example_groups/hook_into_http_library.rb

@@ -1,14 +1,10 @@
 require 'cgi'
 
-NET_CONNECT_NOT_ALLOWED_ERROR = /You can use VCR to automatically record this request and replay it later/
+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, *other|
+shared_examples_for "a hook into an HTTP library" do |library_hook_name, library, *other|
   include HeaderDowncaser
-
-  def interactions_from(file)
-    hashes = YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', file))['http_interactions']
-    hashes.map { |h| VCR::HTTPInteraction.from_hash(h) }
-  end
+  include VCRStubHelpers
 
   unless adapter_module = HTTP_LIBRARY_ADAPTERS[library]
     raise ArgumentError.new("No http library adapter module could be found for #{library}")
@@ -19,10 +15,6 @@ shared_examples_for "a hook into an HTTP library" do |library, *other|
   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
@@ -117,6 +109,196 @@ shared_examples_for "a hook into an HTTP library" do |library, *other|
       test_playback "with an encoded ampersand",        "http://example.com:80/search?q=#{CGI.escape("Q&A")}"
     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!
+          get_body_string(make_http_request(:get, request_url)).should eq("FOO!")
+        end
+
+        it 'does not mess with VCR when real connections are disabled' do
+          VCR.insert_cassette('example')
+          disable_real_connections
+
+          VCR.should_receive(:record_http_interaction) do |interaction|
+            interaction.request.uri.should 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")
+          get_body_string(make_http_request(:get, request_url)).should eq("stubbed response")
+        end
+      end
+    end
+
+    describe "request hooks" do
+      context 'when there is an around_http_request hook' do
+        before(:each) do
+          # ensure that all the other library hooks are disabled so that we don't
+          # get double-hookage (such as for WebMock and Typhoeus both invoking the
+          # hooks for a typhoeus request)
+          VCR.library_hooks.stub(:disabled?) { |lib_name| lib_name != library_hook_name }
+        end
+
+        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
+
+          yielded_request.method.should eq(:get)
+          yielded_request.uri.should eq(request_url)
+        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
+
+          VCR.should_receive(:record_http_interaction) do
+            VCR.current_cassette.name.should eq('new_cassette')
+          end
+
+          VCR.current_cassette.should be_nil
+          make_http_request(:get, request_url)
+          VCR.current_cassette.should 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)
+
+          order.should 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|
+            error.message.should include('must call #proceed on the yielded request')
+            error.message.should 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
+      end if RUBY_VERSION >= '1.9'
+
+      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
+      end
+
+      context 'when the request is recorded' do
+        let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
+
+        it_behaves_like "request hooks", library_hook_name 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
+            get_body_string(make_http_request(:get, 'http://example.com/foo')).should 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 }
+
+            VCR.should_receive(:record_http_interaction) do |interaction|
+              VCR.current_cassette.should be(inserted_cassette)
+            end
+
+            make_request
+            VCR.current_cassette.should 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
+      end
+
+      context 'when the request is not allowed' do
+        it_behaves_like "request hooks", library_hook_name do
+          undef assert_expected_response
+          def assert_expected_response(response)
+            response.should 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) { VCR.stub(:real_http_connections_allowed? => false) }
       let(:interactions) { interactions_from('match_requests_on.yml') }
@@ -277,7 +459,7 @@ shared_examples_for "a hook into an HTTP library" do |library, *other|
         end
 
         context 'when some requests are stubbed' do
-          let(:interactions) { interactions_from('fake_example.com_responses.yml') }
+          let(:interactions) { interactions_from('fake_example_responses.yml') }
           before(:each) do
             stub_requests(interactions, VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
           end

data/spec/support/shared_example_groups/request_hooks.rb

@@ -0,0 +1,58 @@
+shared_examples_for "request hooks" do |library_hook_name|
+  let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
+
+  before(:each) do
+    # ensure that all the other library hooks are disabled so that we don't
+    # get double-hookage (such as for WebMock and Typhoeus both invoking the
+    # hooks for a typhoeus request)
+    VCR.library_hooks.stub(:disabled?) { |lib_name| lib_name != library_hook_name }
+  end
+
+  def make_request(disabled = false)
+    make_http_request(:get, request_url)
+  end
+
+  def assert_expected_response(response)
+    response.status.code.should eq(200)
+    response.body.should eq('FOO!')
+  end
+
+  [:before_http_request, :after_http_request].each do |hook|
+    specify "the #{hook} hook is only called once per request" do
+      call_count = 0
+      VCR.configuration.send(hook) { |r| call_count += 1 }
+
+      make_request
+      call_count.should eq(1)
+    end
+
+    specify "the #{hook} hook yields the request" do
+      request = nil
+      VCR.configuration.send(hook) { |r| request = r }
+
+      make_request
+      request.method.should be(:get)
+      request.uri.should eq(request_url)
+    end
+
+    specify "the #{hook} hook is not called if the library hook is disabled" do
+      VCR.library_hooks.should respond_to(:disabled?)
+      VCR.library_hooks.stub(:disabled? => true)
+
+      hook_called = false
+      VCR.configuration.send(hook) { |r| hook_called = true }
+
+      make_request(:disabled)
+      hook_called.should be_false
+    end
+  end
+
+  specify "the after_http_request hook yields the response if there is one and the second block arg is given" do
+    response = nil
+    VCR.configuration.after_http_request { |req, res| response = res }
+
+    make_request
+    assert_expected_response(response)
+  end
+end
+

data/spec/support/shared_example_groups/version_checking.rb

@@ -1,6 +1,11 @@
 shared_examples_for "version checking" do |library, options|
   file = options[:file] || "vcr/library_hooks/#{library.downcase}.rb"
 
+  before(:each) do
+    # ensure we don't get double callback registration by reloading the file...
+    stub_callback_registration if respond_to?(:stub_callback_registration)
+  end
+
   context 'when loading the library hook file', :disable_warnings => true do
     options[:valid].each do |version|
       it "does nothing when #{library}'s version is #{version}" do

data/spec/support/sinatra_app.rb

@@ -40,20 +40,28 @@ module VCR
       "Response #{$record_and_playback_response_count += 1}"
     end
 
-    def self.port
-      server.port
+    post '/record-and-playback' do
+      "Response #{$record_and_playback_response_count += 1}"
     end
 
     @_boot_failed = false
 
-    def self.server
-      raise "Sinatra app failed to boot." if @_boot_failed
-      @server ||= begin
-        VCR::LocalhostServer.new(new)
-      rescue
-        @_boot_failed = true
-        raise
+    class << self
+      def port
+        server.port
+      end
+
+      def server
+        raise "Sinatra app failed to boot." if @_boot_failed
+        @server ||= begin
+          VCR::LocalhostServer.new(new)
+        rescue
+          @_boot_failed = true
+          raise
+        end
       end
+
+      alias boot server
     end
   end
 end

data/spec/support/vcr_stub_helpers.rb

@@ -0,0 +1,17 @@
+module VCRStubHelpers
+  def interactions_from(file)
+    hashes = YAML.load_file(File.join(VCR::SPEC_ROOT, 'fixtures', file))['http_interactions']
+    hashes.map { |h| VCR::HTTPInteraction.from_hash(h) }
+  end
+
+  def stub_requests(*args)
+    VCR.stub(:http_interactions => VCR::Cassette::HTTPInteractionList.new(*args))
+  end
+
+  def http_interaction(url, response_body = "FOO!", status_code = 200)
+    request = VCR::Request.new(:get, request_url)
+    response_status = VCR::ResponseStatus.new(status_code)
+    response = VCR::Response.new(response_status, nil, response_body, '1.1')
+    VCR::HTTPInteraction.new(request, response)
+  end
+end