vcr 2.0.0.beta2 → 2.0.0.rc1

data/spec/vcr/library_hooks/faraday_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'vcr/library_hooks/faraday'
+
+describe "Faraday hook" do
+  it 'inserts the VCR middleware just before the adapter' do
+    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
+      builder.request  :url_encoded
+      builder.request  :json
+      builder.response :logger
+      builder.adapter  :net_http
+    end
+
+    conn.builder.lock!
+    conn.builder.handlers.last(2).map(&:klass).should eq([
+      VCR::Middleware::Faraday,
+      Faraday::Adapter::NetHttp
+    ])
+  end
+
+  it 'handles the case where no adapter is declared' do
+    conn = Faraday.new
+
+    conn.builder.lock!
+    conn.builder.handlers.last(2).map(&:klass).should eq([
+      VCR::Middleware::Faraday,
+      Faraday::Adapter::NetHttp
+    ])
+  end
+
+  it 'does nothing if the VCR middleware has already been included' do
+    conn = Faraday.new(:url => 'http://sushi.com') do |builder|
+      builder.use VCR::Middleware::Faraday
+      builder.use Faraday::Response::Logger
+      builder.use Faraday::Adapter::NetHttp
+    end
+
+    conn.builder.lock!
+    conn.builder.handlers.map(&:klass).should eq([
+      VCR::Middleware::Faraday,
+      Faraday::Response::Logger,
+      Faraday::Adapter::NetHttp
+    ])
+  end
+end
+

data/spec/vcr/library_hooks/typhoeus_spec.rb

@@ -1,7 +1,35 @@
 require 'spec_helper'
 
 describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
-  it_behaves_like 'a hook into an HTTP library', 'typhoeus'
+  after(:each) do
+    ::Typhoeus::Hydra.clear_stubs
+  end
+
+  def disable_real_connections
+    ::Typhoeus::Hydra.allow_net_connect = false
+    ::Typhoeus::Hydra::NetConnectNotAllowedError
+  end
+
+  def enable_real_connections
+    ::Typhoeus::Hydra.allow_net_connect = true
+  end
+
+  def directly_stub_request(method, url, response_body)
+    response = ::Typhoeus::Response.new(:code => 200, :body => response_body)
+    ::Typhoeus::Hydra.stub(method, url).and_return(response)
+  end
+
+  it_behaves_like 'a hook into an HTTP library', :typhoeus, 'typhoeus'
+
+  def stub_callback_registration
+    # stub the callback registration methods so we don't get a second
+    # callback registered when we load the typhoeus file below.
+    # Note that we have to use `stub!`, not `stub` because
+    # Typhoeus::Hydra defines its own stub method...so to use RSpec's,
+    # we use stub!
+    ::Typhoeus::Hydra.stub!(:after_request_before_on_complete)
+    ::Typhoeus::Hydra.stub!(:register_stub_finder)
+  end
 
   it_performs('version checking', 'Typhoeus',
     :valid    => %w[ 0.3.2 0.3.10 ],
@@ -18,6 +46,8 @@ describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
   end
 
   describe "VCR.configuration.after_library_hooks_loaded hook", :disable_warnings do
+    before(:each) { stub_callback_registration }
+
     it 'disables the webmock typhoeus adapter so it does not conflict with our typhoeus hook' do
       load "vcr/library_hooks/typhoeus.rb" # to re-add the hook since it's cleared by each test
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.should_receive(:disable!)

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -1,8 +1,25 @@
 require 'spec_helper'
 
 describe "WebMock hook", :with_monkey_patches => :webmock do
+  after(:each) do
+    ::WebMock.reset!
+  end
+
+  def disable_real_connections
+    ::WebMock.disable_net_connect!
+    ::WebMock::NetConnectNotAllowedError
+  end
+
+  def enable_real_connections
+    ::WebMock.allow_net_connect!
+  end
+
+  def directly_stub_request(method, url, response_body)
+    ::WebMock.stub_request(method, url).to_return(:body => response_body)
+  end
+
   %w[net/http patron httpclient em-http-request curb typhoeus].each do |lib|
-    it_behaves_like 'a hook into an HTTP library', lib do
+    it_behaves_like 'a hook into an HTTP library', :webmock, lib do
       if lib == 'net/http'
         def normalize_request_headers(headers)
           headers.merge(DEFAULT_REQUEST_HEADERS)
@@ -12,10 +29,16 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
   end
 
   it_performs('version checking', 'WebMock',
-    :valid    => %w[ 1.7.0 1.7.99 ],
-    :too_low  => %w[ 0.9.9 0.9.10 0.1.30 1.0.30 1.6.9 ],
+    :valid    => %w[ 1.7.8 1.7.10 1.7.99 ],
+    :too_low  => %w[ 0.9.9 0.9.10 0.1.30 1.0.30 1.7.7 ],
     :too_high => %w[ 1.8.0 1.10.0 2.0.0 ]
   ) do
+
+    def stub_callback_registration
+      ::WebMock.stub(:after_request)
+      ::WebMock.stub(:globally_stub_request)
+    end
+
     def stub_version(version)
       WebMock.stub(:version).and_return(version)
     end

data/spec/vcr/middleware/faraday_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
+require 'vcr/library_hooks/faraday'
 
 describe VCR::Middleware::Faraday do
   %w[ typhoeus net_http patron ].each do |lib|
-    it_behaves_like 'a hook into an HTTP library', "faraday (w/ #{lib})",
+    it_behaves_like 'a hook into an HTTP library', :faraday, "faraday (w/ #{lib})",
       :status_message_not_exposed,
       :does_not_support_rotating_responses,
       :not_disableable
@@ -22,4 +23,86 @@ describe VCR::Middleware::Faraday do
       ::Faraday::VERSION = version
     end
   end
+
+  context 'when making parallel requests' do
+    include VCRStubHelpers
+    let(:parallel_manager)   { ::Faraday::Adapter::Typhoeus.setup_parallel_manager }
+    let(:connection)         { ::Faraday.new { |b| b.adapter :typhoeus } }
+
+    shared_examples_for "exclusive library hook" do
+      let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/" }
+
+      def make_request
+        connection.in_parallel(parallel_manager) { connection.get(request_url) }
+      end
+
+      it 'makes the faraday middleware exclusively enabled for the duration of the request' do
+        VCR.library_hooks.should_not be_disabled(:fakeweb)
+
+        hook_called = false
+        VCR.configuration.after_http_request do
+          hook_called = true
+          VCR.library_hooks.should be_disabled(:fakeweb)
+        end
+
+        make_request
+        VCR.library_hooks.should_not be_disabled(:fakeweb)
+        hook_called.should be_true
+      end
+    end
+
+    context 'for an ignored request' do
+      before(:each) { VCR.configuration.ignore_request { true } }
+      it_behaves_like "exclusive library hook"
+    end
+
+    context 'for a stubbed request' do
+      it_behaves_like "exclusive library hook" do
+        before(:each) do
+          stub_requests([http_interaction(request_url)], [:method, :uri])
+        end
+      end
+    end
+
+    context 'for a recorded request' do
+      let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
+      before(:each) { VCR.should_receive(:record_http_interaction) }
+      it_behaves_like "exclusive library hook"
+    end
+
+    context 'for a disallowed request' do
+      it_behaves_like "exclusive library hook" do
+        undef make_request
+        def make_request
+          expect {
+            connection.in_parallel(parallel_manager) { connection.get(request_url) }
+          }.to raise_error(VCR::Errors::UnhandledHTTPRequestError)
+        end
+      end
+    end
+
+    it_behaves_like "request hooks", :faraday do
+      let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
+
+      undef make_request
+      def make_request(disabled = false)
+        response = nil
+        connection.in_parallel(parallel_manager) do
+          response = connection.get(request_url)
+        end
+        response
+      end
+
+      it '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 if defined?(::Typhoeus)
 end

data/spec/vcr/request_ignorer_spec.rb

@@ -49,6 +49,22 @@ module VCR
         it_behaves_like "#ignore?", "http://#{host}/foo", false
       end
     end
+
+    context 'when a custom ignore_request hook has been set' do
+      before(:each) do
+        subject.ignore_request do |request|
+          URI(request.uri).port == 5
+        end
+      end
+
+      it 'ignores requests for which the block returns true' do
+        subject.ignore?(request('http://foo.com:5/bar')).should be_true
+      end
+
+      it 'does not ignore requests for which the block returns false' do
+        subject.ignore?(request('http://foo.com:6/bar')).should be_false
+      end
+    end
   end
 end
 

data/spec/vcr/request_matcher_registry_spec.rb

@@ -168,32 +168,6 @@ module VCR
             request_with(:uri => 'http://foo2.com/bar?baz=7')
           ).should be_false
         end
-
-        it 'does not consider the standard HTTP port' do
-          subject[:uri].matches?(
-            request_with(:uri => 'http://foo.com:80/bar?baz=7'),
-            request_with(:uri => 'http://foo.com/bar?baz=7')
-          ).should be_true
-        end
-
-        it 'does not consider the standard HTTPS port' do
-          subject[:uri].matches?(
-            request_with(:uri => 'https://foo.com/bar?baz=7'),
-            request_with(:uri => 'https://foo.com:443/bar?baz=7')
-          ).should be_true
-        end
-
-        it 'considers non-standard ports' do
-          subject[:uri].matches?(
-            request_with(:uri => 'http://foo.com:79/bar?baz=7'),
-            request_with(:uri => 'http://foo.com:78/bar?baz=7')
-          ).should be_false
-
-          subject[:uri].matches?(
-            request_with(:uri => 'https://foo.com:442/bar?baz=7'),
-            request_with(:uri => 'https://foo.com:441/bar?baz=7')
-          ).should be_false
-        end
       end
 
       describe ":host" do

data/spec/vcr/structs_spec.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'yaml'
 require 'vcr/structs'
 
@@ -222,7 +224,7 @@ module VCR
       end
 
       it 'replaces sensitive text in the request URI' do
-        subject.request.uri.should eq('http://example-AAA.com:80/AAA/')
+        subject.request.uri.should eq('http://example-AAA.com/AAA/')
       end
     end
   end
@@ -244,8 +246,59 @@ module VCR
           m.call.should eq(described_class)
         end
       end
+
+      it 'gets normalized to a lowercase symbol' do
+        VCR::Request.new("GET").method.should eq(:get)
+        VCR::Request.new(:GET).method.should eq(:get)
+        VCR::Request.new(:get).method.should eq(:get)
+        VCR::Request.new("get").method.should eq(:get)
+      end
+    end
+
+    describe "#uri" do
+      def uri_for(uri)
+        VCR::Request.new(:get, uri).uri
+      end
+
+      it 'removes the default http port' do
+        uri_for("http://foo.com:80/bar").should eq("http://foo.com/bar")
+      end
+
+      it 'removes the default https port' do
+        uri_for("https://foo.com:443/bar").should eq("https://foo.com/bar")
+      end
+
+      it 'does not remove a non-standard http port' do
+        uri_for("http://foo.com:81/bar").should eq("http://foo.com:81/bar")
+      end
+
+      it 'does not remove a non-standard https port' do
+        uri_for("https://foo.com:442/bar").should eq("https://foo.com:442/bar")
+      end
     end
 
+    describe "#fiber_aware" do
+      it 'adds a #proceed method that yields in a fiber' do
+        fiber = Fiber.new do |request|
+          request.proceed
+          :done
+        end
+
+        fiber.resume(subject.fiber_aware).should be_nil
+        fiber.resume.should eq(:done)
+      end
+
+      it 'can be cast to a proc' do
+        request = subject.fiber_aware
+        request.should_receive(:proceed)
+        lambda(&request).call
+      end
+
+      it 'returns the request' do
+        subject.fiber_aware.should be(subject)
+      end
+    end if RUBY_VERSION > '1.9'
+
     it_behaves_like 'a header normalizer' do
       def with_headers(headers)
         described_class.new(:get, 'http://example.com/', nil, headers)
@@ -301,6 +354,13 @@ module VCR
               inst.update_content_length_header
             }.to change { inst.headers[header] }.from(['3']).to(['0'])
           end
+
+          it 'sets the header according to RFC 2616 based on the number of bytes (not the number of characters)' do
+            inst = instance('aؼ', '2') # the second char is a double byte char
+            expect {
+              inst.update_content_length_header
+            }.to change { inst.headers[header] }.from(['2']).to(['3'])
+          end
         end
       end
     end

data/spec/vcr/test_frameworks/rspec_spec.rb

@@ -1,5 +1,37 @@
 require 'spec_helper'
 
+RSpec.configure do |config|
+  config.before(:suite) do
+    VCR.configuration.configure_rspec_metadata!
+  end
+end
+
+describe VCR::RSpec::Metadata, :skip_vcr_reset do
+  before(:all) { VCR.reset! }
+  after(:each) { VCR.reset! }
+
+  context 'an example group', :vcr do
+    context 'with a nested example group' do
+      it 'uses a cassette for any examples' do
+        VCR.current_cassette.name.split('/').should eq([
+          'VCR::RSpec::Metadata',
+          'an example group',
+          'with a nested example group',
+          'uses a cassette for any examples'
+        ])
+      end
+    end
+  end
+
+  it 'allows the cassette name to be overriden', :vcr => { :cassette_name => 'foo' } do
+    VCR.current_cassette.name.should eq('foo')
+  end
+
+  it 'allows the cassette options to be set', :vcr => { :match_requests_on => [:method] } do
+    VCR.current_cassette.match_requests_on.should eq([:method])
+  end
+end
+
 describe VCR::RSpec::Macros do
   extend described_class
 

data/spec/vcr/util/hooks_spec.rb

@@ -17,76 +17,86 @@ describe VCR::Hooks do
     it 'clears all hooks' do
       subject.before_foo { invocations << :callback }
       subject.clear_hooks
-      subject.invoke_hook(:before_foo, nil)
+      subject.invoke_hook(:before_foo)
       invocations.should be_empty
     end
   end
 
   describe '#invoke_hook(:before_foo)' do
-    context 'with a tag argument' do
-      it 'invokes each of the :before_foo callbacks with a matching tag' do
-        subject.before_foo(:green) { invocations << :callback_1 }
-        subject.before_foo(:green) { invocations << :callback_2 }
-
-        invocations.should be_empty
-        subject.invoke_hook(:before_foo, :green)
-        invocations.should eq([:callback_1, :callback_2])
-      end
-
-      it 'invokes each of the :before_foo callbacks with no tag' do
-        subject.before_foo { invocations << :no_tag_1 }
-        subject.before_foo { invocations << :no_tag_2 }
-
-        subject.invoke_hook(:before_foo, :green)
-        invocations.should eq([:no_tag_1, :no_tag_2])
-      end
-
-      it 'does not invoke any callbacks with a different tag' do
-        subject.before_foo(:blue) { invocations << :blue_callback }
-        subject.invoke_hook(:before_foo, :green)
-        invocations.should be_empty
-      end
+    it 'maps the return value of each callback' do
+      subject.before_foo { 17 }
+      subject.before_foo { 12 }
+      subject.invoke_hook(:before_foo).should eq([17, 12])
     end
 
-    context 'without a tag argument' do
-      it 'invokes each of the :before_foo callbacks' do
-        subject.before_foo { invocations << :callback_1 }
-        subject.before_foo { invocations << :callback_2 }
-
-        invocations.should be_empty
-        subject.invoke_hook(:before_foo, nil)
-        invocations.should eq([:callback_1, :callback_2])
-      end
-
-      it 'does not invoke :before_bar callbacks' do
-        subject.before_bar { invocations << :bar_callback }
-        subject.invoke_hook(:before_foo, nil)
-        invocations.should be_empty
-      end
-
-      it 'does not invoke any tagged callbacks' do
-        subject.before_foo(:blue) { invocations << :blue_callback }
-        subject.invoke_hook(:before_foo, nil)
-        invocations.should be_empty
-      end
-
-      it 'passes along the provided arguments to the callback' do
-        subject.before_foo(&lambda { |a, b| invocations << [a, b] })
-        subject.invoke_hook(:before_foo, nil, :arg1, :arg2)
-        invocations.flatten.should eq([:arg1, :arg2])
-      end
-
-      it 'only passes along 1 argument when the block accepts only 1 arguments' do
-        subject.before_foo(&lambda { |a| invocations << a })
-        subject.invoke_hook(:before_foo, nil, :arg1, :arg2)
-        invocations.flatten.should eq([:arg1])
-      end
-
-      it 'passes along all arguments when the block accepts a variable number of args' do
-        subject.before_foo(&lambda { |*a| invocations << a })
-        subject.invoke_hook(:before_foo, nil, :arg1, :arg2)
-        invocations.flatten.should eq([:arg1, :arg2])
-      end
+    it 'invokes each of the :before_foo callbacks' do
+      subject.before_foo { invocations << :callback_1 }
+      subject.before_foo { invocations << :callback_2 }
+
+      invocations.should be_empty
+      subject.invoke_hook(:before_foo)
+      invocations.should eq([:callback_1, :callback_2])
+    end
+
+    it 'does not invoke :before_bar callbacks' do
+      subject.before_bar { invocations << :bar_callback }
+      subject.invoke_hook(:before_foo)
+      invocations.should be_empty
+    end
+
+    it 'does not invoke any tagged callbacks' do
+      subject.before_foo(:blue) { invocations << :blue_callback }
+      subject.invoke_hook(:before_foo)
+      invocations.should be_empty
+    end
+
+    it 'passes along the provided arguments to the callback' do
+      subject.before_foo(&lambda { |a, b| invocations << [a, b] })
+      subject.invoke_hook(:before_foo, :arg1, :arg2)
+      invocations.flatten.should eq([:arg1, :arg2])
+    end
+
+    it 'only passes along 1 argument when the block accepts only 1 arguments' do
+      subject.before_foo(&lambda { |a| invocations << a })
+      subject.invoke_hook(:before_foo, :arg1, :arg2)
+      invocations.flatten.should eq([:arg1])
+    end
+
+    it 'passes along all arguments when the block accepts a variable number of args' do
+      subject.before_foo(&lambda { |*a| invocations << a })
+      subject.invoke_hook(:before_foo, :arg1, :arg2)
+      invocations.flatten.should eq([:arg1, :arg2])
+    end
+  end
+
+  describe "#invoke_tagged_hook(:before_foo, tag)" do
+    it 'invokes each of the :before_foo callbacks with a matching tag' do
+      subject.before_foo(:green) { invocations << :callback_1 }
+      subject.before_foo(:green) { invocations << :callback_2 }
+
+      invocations.should be_empty
+      subject.invoke_tagged_hook(:before_foo, :green)
+      invocations.should eq([:callback_1, :callback_2])
+    end
+
+    it 'invokes each of the :before_foo callbacks with no tag' do
+      subject.before_foo { invocations << :no_tag_1 }
+      subject.before_foo { invocations << :no_tag_2 }
+
+      subject.invoke_hook(:before_foo, :green)
+      invocations.should eq([:no_tag_1, :no_tag_2])
+    end
+
+    it 'does not invoke any callbacks with a different tag' do
+      subject.before_foo(:blue) { invocations << :blue_callback }
+      subject.invoke_tagged_hook(:before_foo, :green)
+      invocations.should be_empty
+    end
+
+    it 'passes along the provided arguments to the callback' do
+      subject.before_foo(:green, &lambda { |a, b| invocations << [a, b] })
+      subject.invoke_tagged_hook(:before_foo, :green, :arg1, :arg2)
+      invocations.flatten.should eq([:arg1, :arg2])
     end
   end
 end