vcr 2.0.0.rc1 → 2.0.0.rc2

data/spec/vcr/configuration_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe VCR::Configuration do
   describe '#cassette_library_dir=' do
     let(:tmp_dir) { VCR::SPEC_ROOT + '/../tmp/cassette_library_dir/new_dir' }
-    after(:each) { FileUtils.rm_rf tmp_dir }
+    after(:each)  { FileUtils.rm_rf tmp_dir }
 
     it 'creates the directory if it does not exist' do
       expect { subject.cassette_library_dir = tmp_dir }.to change { File.exist?(tmp_dir) }.from(false).to(true)
@@ -12,6 +12,13 @@ describe VCR::Configuration do
     it 'does not raise an error if given nil' do
       expect { subject.cassette_library_dir = nil }.to_not raise_error
     end
+
+    it 'resolves the given directory to an absolute path, so VCR continues to work even if the current directory changes' do
+      relative_dir = 'tmp/cassette_library_dir/new_dir'
+      subject.cassette_library_dir = relative_dir
+      absolute_dir = File.join(VCR::SPEC_ROOT.sub(/\/spec\z/, ''), relative_dir)
+      subject.cassette_library_dir.should eq(absolute_dir)
+    end
   end
 
   describe '#default_cassette_options' do
@@ -110,21 +117,51 @@ describe VCR::Configuration do
     end
   end
 
+  describe "#before_record hook", :with_monkey_patches => :fakeweb do
+    specify 'the request on the yielded interaction is not typed even though the request given to before_http_request is' do
+      before_record_req = before_request_req = nil
+      VCR.configure do |c|
+        c.before_http_request { |r| before_request_req = r }
+        c.before_record { |i| before_record_req = i.request }
+      end
+
+      VCR.use_cassette("example") do
+        ::Net::HTTP.get_response(URI("http://localhost:#{VCR::SinatraApp.port}/foo"))
+      end
+
+      before_record_req.should_not respond_to(:type)
+      before_request_req.should respond_to(:type)
+    end unless RUBY_VERSION =~ /^1\.8/
+  end
+
+  [:before_record, :before_playback].each do |hook_type|
+    describe "##{hook_type}" do
+      it 'sets up a tag filter' do
+        called = false
+        VCR.configuration.send(hook_type, :my_tag) { called = true }
+        VCR.configuration.invoke_hook(hook_type, stub, stub(:tags => []))
+        called.should be_false
+        VCR.configuration.invoke_hook(hook_type, stub, stub(:tags => [:my_tag]))
+        called.should be_true
+      end
+    end
+  end
+
   %w[ filter_sensitive_data define_cassette_placeholder ].each do |method|
     describe "##{method}" do
-      let(:interaction) { mock('interaction') }
+      let(:interaction) { mock('interaction').as_null_object }
       before(:each) { interaction.stub(:filter!) }
 
       it 'adds a before_record hook that replaces the string returned by the block with the given string' do
         subject.send(method, 'foo', &lambda { 'bar' })
         interaction.should_receive(:filter!).with('bar', 'foo')
-        subject.invoke_hook(:before_record, interaction)
+        subject.invoke_hook(:before_record, interaction, stub.as_null_object)
       end
 
       it 'adds a before_playback hook that replaces the given string with the string returned by the block' do
         subject.send(method, 'foo', &lambda { 'bar' })
         interaction.should_receive(:filter!).with('foo', 'bar')
-        subject.invoke_hook(:before_playback, interaction)
+        subject.invoke_hook(:before_playback, interaction, stub.as_null_object)
       end
 
       it 'tags the before_record hook when given a tag' do
@@ -140,14 +177,14 @@ describe VCR::Configuration do
       it 'yields the interaction to the block for the before_record hook' do
         yielded_interaction = nil
         subject.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
-        subject.invoke_hook(:before_record, interaction)
+        subject.invoke_hook(:before_record, interaction, stub.as_null_object)
         yielded_interaction.should equal(interaction)
       end
 
       it 'yields the interaction to the block for the before_playback hook' do
         yielded_interaction = nil
         subject.send(method, 'foo', &lambda { |i| yielded_interaction = i; 'bar' })
-        subject.invoke_hook(:before_playback, interaction)
+        subject.invoke_hook(:before_playback, interaction, stub.as_null_object)
         yielded_interaction.should equal(interaction)
       end
     end
@@ -169,4 +206,52 @@ describe VCR::Configuration do
       subject.cassette_serializers[:custom].should be(custom_serializer)
     end
   end
+
+  describe "#preserve_exact_body_bytes_for?" do
+    def message_for(body)
+      stub(:body => body)
+    end
+
+    context "default hook" do
+      it "returns false when there is no current cassette" do
+        subject.preserve_exact_body_bytes_for?(message_for "string").should be_false
+      end
+
+      it "returns false when the current cassette has been created without the :preserve_exact_body_bytes option" do
+        VCR.insert_cassette('foo')
+        subject.preserve_exact_body_bytes_for?(message_for "string").should be_false
+      end
+
+      it 'returns true when the current cassette has been created with the :preserve_exact_body_bytes option' do
+        VCR.insert_cassette('foo', :preserve_exact_body_bytes => true)
+        subject.preserve_exact_body_bytes_for?(message_for "string").should be_true
+      end
+    end
+
+    it "returns true when the configured block returns true" do
+      subject.preserve_exact_body_bytes { |msg| msg.body == "a" }
+      subject.preserve_exact_body_bytes_for?(message_for "a").should be_true
+      subject.preserve_exact_body_bytes_for?(message_for "b").should be_false
+    end
+
+    it "returns true when any of the registered blocks returns true" do
+      called_hooks = []
+      subject.preserve_exact_body_bytes { called_hooks << :hook_1; false }
+      subject.preserve_exact_body_bytes { called_hooks << :hook_2; true }
+      subject.preserve_exact_body_bytes_for?(message_for "a").should be_true
+      called_hooks.should eq([:hook_1, :hook_2])
+    end
+
+    it "invokes the configured hook with the http message and the current cassette" do
+      VCR.use_cassette('example') do |cassette|
+        cassette.should be_a(VCR::Cassette)
+        message = stub(:message)
+
+        yielded_objects = nil
+        subject.preserve_exact_body_bytes { |a, b| yielded_objects = [a, b] }
+        subject.preserve_exact_body_bytes_for?(message)
+        yielded_objects.should eq([message, cassette])
+      end
+    end
+  end
 end

data/spec/vcr/library_hooks/excon_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "Excon hook" do
+describe "Excon hook", :with_monkey_patches => :excon do
   # TODO: figure out a way to get disabling VCR to work with Excon
   #       and allow dirct excon stubs to work.
   # def directly_stub_request(method, url, response_body)
@@ -9,20 +9,6 @@ describe "Excon hook" do
 
   it_behaves_like 'a hook into an HTTP library', :excon, 'excon', :status_message_not_exposed
 
-  it_performs('version checking', 'Excon',
-    :valid    => %w[ 0.6.5 0.7.9 ],
-    :too_low  => %w[ 0.5.99 0.6.4 ],
-    :too_high => %w[ 0.8.0 1.0.0 ]
-  ) do
-    before(:each) { @orig_version = Excon::VERSION }
-    after(:each)  { Excon::VERSION = @orig_version }
-
-    # Cannot be regular method def as that raises a "dynamic constant assignment" error
-    define_method :stub_version do |version|
-      Excon::VERSION = version
-    end
-  end
-
   context "when the query is specified as a hash option" do
     let(:excon) { ::Excon.new("http://localhost:#{VCR::SinatraApp.port}/search") }
 
@@ -74,7 +60,51 @@ describe "Excon hook" do
       }.to raise_error(Excon::Errors::Error)
     end
 
-    it_behaves_like "request hooks", :excon do
+    it 'performs the right number of retries' do
+      connection = Excon.new("http://localhost:#{VCR::SinatraApp.port}/not_found")
+
+      # Excon define's .stub so we can't use RSpec's here...
+      Excon.should_receive(:new).at_least(:once).and_return(connection)
+
+      connection.extend Module.new {
+        def request_kernel_call_counts
+          @request_kernel_call_counts ||= Hash.new(0)
+        end
+
+        def request_kernel(params, &block)
+          request_kernel_call_counts[params[:mock]] += 1
+          super
+        end
+      }
+
+      expect {
+        connection.get(:expects => 200, :idempotent => true, :retry_limit => 3)
+      }.to raise_error(Excon::Errors::Error)
+
+      connection.request_kernel_call_counts.should eq(true => 3, false => 3)
+    end
+
+    def error_raised_by
+      yield
+    rescue => e
+      return e
+    else
+      raise "No error was raised"
+    end
+
+    it 'raises the same error class as excon itself raises' do
+      real_error, stubbed_error = 2.times.map do
+        error_raised_by do
+          VCR.use_cassette('excon_error', :record => :once) do
+            Excon.get("http://localhost:#{VCR::SinatraApp.port}/not_found", :expects => 200)
+          end
+        end
+      end
+
+      stubbed_error.class.should be(real_error.class)
+    end
+
+    it_behaves_like "request hooks", :excon, :recordable do
       undef make_request
       def make_request(disabled = false)
         expect {
@@ -83,5 +113,13 @@ describe "Excon hook" do
       end
     end
   end
+
+  describe "VCR.configuration.after_library_hooks_loaded hook" do
+    it 'disables the webmock excon adapter so it does not conflict with our typhoeus hook' do
+      ::WebMock::HttpLibAdapters::ExconAdapter.should respond_to(:disable!)
+      ::WebMock::HttpLibAdapters::ExconAdapter.should_receive(:disable!)
+      $excon_after_loaded_hook.conditionally_invoke
+    end
+  end
 end
 

data/spec/vcr/library_hooks/fakeweb_spec.rb

@@ -29,25 +29,20 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
     end
   end
 
-  it_performs('version checking', 'FakeWeb',
-    :valid    => %w[ 1.3.0 1.3.1 1.3.99 ],
-    :too_low  => %w[ 1.2.8 1.1.30 0.30.30 ],
-    :too_high => %w[ 1.4.0 1.10.0 2.0.0 ]
-  ) do
-    before(:each) { @orig_version = FakeWeb::VERSION }
-    after(:each)  { FakeWeb::VERSION = @orig_version }
-
-    # Cannot be regular method def as that raises a "dynamic constant assignment" error
-    define_method :stub_version do |version|
-      FakeWeb::VERSION = version
-    end
-  end
-
   describe "some specific Net::HTTP edge cases" do
     before(:each) do
       VCR.stub(:real_http_connections_allowed? => true)
     end
 
+    it 'records the request body when using #post_form' do
+      VCR.should_receive(:record_http_interaction) do |interaction|
+        interaction.request.body.should eq("q=ruby")
+      end
+
+      uri = URI("http://localhost:#{VCR::SinatraApp.port}/foo")
+      Net::HTTP.post_form(uri, 'q' => 'ruby')
+    end
+
     it "does not record headers for which Net::HTTP sets defaults near the end of the real request" do
       VCR.should_receive(:record_http_interaction) do |interaction|
         interaction.request.headers.should_not have_key('content-type')
@@ -102,12 +97,8 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
     end
   end
 
-  describe "VCR.configuration.after_library_hooks_loaded hook", :disable_warnings do
-    before(:each) do
-      load "vcr/library_hooks/fakeweb.rb" # to re-add the hook since it's cleared by each test
-    end
-
-    let(:run_hook) { VCR.configuration.invoke_hook(:after_library_hooks_loaded) }
+  describe "VCR.configuration.after_library_hooks_loaded hook" do
+    let(:run_hook) { $fakeweb_after_loaded_hook.conditionally_invoke }
 
     context 'when WebMock has been loaded' do
       before(:each) { defined?(WebMock).should be_true }
@@ -133,7 +124,7 @@ describe "FakeWeb hook", :with_monkey_patches => :fakeweb do
       VCR.configuration.ignore_request { |r| true }
     end
 
-    it_behaves_like "request hooks", :fakeweb do
+    it_behaves_like "request hooks", :fakeweb, :ignored do
       undef assert_expected_response
       def assert_expected_response(response)
         response.should be_nil

data/spec/vcr/library_hooks/typhoeus_spec.rb

@@ -21,37 +21,10 @@ describe "Typhoeus hook", :with_monkey_patches => :typhoeus do
 
   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 ],
-    :too_low  => %w[ 0.2.0 0.2.31 0.3.1 ],
-    :too_high => %w[ 0.4.0 1.0.0 ]
-  ) do
-    before(:each) { @orig_version = Typhoeus::VERSION }
-    after(:each)  { Typhoeus::VERSION = @orig_version }
-
-    # Cannot be regular method def as that raises a "dynamic constant assignment" error
-    define_method :stub_version do |version|
-      Typhoeus::VERSION = version
-    end
-  end
-
-  describe "VCR.configuration.after_library_hooks_loaded hook", :disable_warnings do
-    before(:each) { stub_callback_registration }
-
+  describe "VCR.configuration.after_library_hooks_loaded hook" do
     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!)
-      VCR.configuration.invoke_hook(:after_library_hooks_loaded)
+      $typhoeus_after_loaded_hook.conditionally_invoke
     end
   end
 end unless RUBY_PLATFORM == 'java'

data/spec/vcr/library_hooks/webmock_spec.rb

@@ -18,8 +18,10 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
     ::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', :webmock, lib do
+  %w[net/http patron httpclient em-http-request curb typhoeus excon].each do |lib|
+    other = []
+    other << :status_message_not_exposed if lib == 'excon'
+    it_behaves_like 'a hook into an HTTP library', :webmock, lib, *other do
       if lib == 'net/http'
         def normalize_request_headers(headers)
           headers.merge(DEFAULT_REQUEST_HEADERS)
@@ -27,20 +29,4 @@ describe "WebMock hook", :with_monkey_patches => :webmock do
       end
     end
   end
-
-  it_performs('version checking', 'WebMock',
-    :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
-  end
 end

data/spec/vcr/middleware/faraday_spec.rb

@@ -9,21 +9,6 @@ describe VCR::Middleware::Faraday do
       :not_disableable
   end
 
-  it_performs('version checking', 'Faraday',
-    :valid    => %w[ 0.7.0 0.7.10 ],
-    :too_low  => %w[ 0.6.9 0.5.99 ],
-    :too_high => %w[ 0.8.0 1.0.0 ],
-    :file     => 'vcr/middleware/faraday.rb'
-  ) do
-    before(:each) { @orig_version = Faraday::VERSION }
-    after(:each)  { Faraday::VERSION = @orig_version }
-
-    # Cannot be regular method def as that raises a "dynamic constant assignment" error
-    define_method :stub_version do |version|
-      ::Faraday::VERSION = version
-    end
-  end
-
   context 'when making parallel requests' do
     include VCRStubHelpers
     let(:parallel_manager)   { ::Faraday::Adapter::Typhoeus.setup_parallel_manager }
@@ -81,7 +66,7 @@ describe VCR::Middleware::Faraday do
       end
     end
 
-    it_behaves_like "request hooks", :faraday do
+    it_behaves_like "request hooks", :faraday, :recordable do
       let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
 
       undef make_request

data/spec/vcr/structs_spec.rb

@@ -49,23 +49,13 @@ end
 
 module VCR
   describe HTTPInteraction do
-    %w( uri method ).each do |attr|
-      it "delegates :#{attr} to the request" do
-        sig = mock('request')
-        sig.should_receive(attr).and_return(:the_value)
-        instance = described_class.new(sig, nil)
-        instance.send(attr).should eq(:the_value)
+    if ''.respond_to?(:encoding)
+      def body_hash(key, value)
+        { key => value, 'encoding' => 'UTF-8' }
       end
-    end
-
-    describe '#ignored?' do
-      it 'returns false by default' do
-        should_not be_ignored
-      end
-
-      it 'returns true when #ignore! has been called' do
-        subject.ignore!
-        should be_ignored
+    else
+      def body_hash(key, value)
+        { key => value }
       end
     end
 
@@ -90,7 +80,7 @@ module VCR
           'request' => {
             'method'  => 'get',
             'uri'     => 'http://foo.com/',
-            'body'    => 'req body',
+            'body'    => body_hash('string', 'req body'),
             'headers' => { "bar" => ["foo"] }
           },
           'response' => {
@@ -99,7 +89,7 @@ module VCR
               'message'    => 'OK'
             },
             'headers'      => { "foo"     => ["bar"] },
-            'body'         => 'res body',
+            'body'         => body_hash('string', 'res body'),
             'http_version' => '1.1'
           },
           'recorded_at' => "Wed, 04 May 2011 12:30:00 GMT"
@@ -125,9 +115,86 @@ module VCR
         i = HTTPInteraction.from_hash(hash)
         i.response.should eq(Response.new(ResponseStatus.new))
       end
+
+      it 'decodes the base64 body string' do
+        hash['request']['body'] = body_hash('base64_string', Base64.encode64('req body'))
+        hash['response']['body'] = body_hash('base64_string', Base64.encode64('res body'))
+
+        i = HTTPInteraction.from_hash(hash)
+        i.request.body.should eq('req body')
+        i.response.body.should eq('res body')
+      end
+
+      if ''.respond_to?(:encoding)
+        it 'force encodes the decoded base64 string as the original encoding' do
+          string = "café"
+          string.force_encoding("US-ASCII")
+          string.should_not be_valid_encoding
+
+          hash['request']['body']  = { 'base64_string' => Base64.encode64(string.dup), 'encoding' => 'US-ASCII' }
+          hash['response']['body'] = { 'base64_string' => Base64.encode64(string.dup), 'encoding' => 'US-ASCII' }
+
+          i = HTTPInteraction.from_hash(hash)
+          i.request.body.encoding.name.should eq("US-ASCII")
+          i.response.body.encoding.name.should eq("US-ASCII")
+          i.request.body.bytes.to_a.should eq(string.bytes.to_a)
+          i.response.body.bytes.to_a.should eq(string.bytes.to_a)
+          i.request.body.should_not be_valid_encoding
+          i.response.body.should_not be_valid_encoding
+        end
+
+        it 'does not attempt to force encode the decoded base64 string when there is no encoding given (i.e. if the cassette was recorded on ruby 1.8)' do
+          hash['request']['body']  = { 'base64_string' => Base64.encode64('foo') }
+
+          i = HTTPInteraction.from_hash(hash)
+          i.request.body.should eq('foo')
+          i.request.body.encoding.name.should eq("ASCII-8BIT")
+        end
+
+        it 'tries to encode strings to the original encoding' do
+          hash['request']['body']  = { 'string' => "abc", 'encoding' => 'ISO-8859-1' }
+          hash['response']['body'] = { 'string' => "abc", 'encoding' => 'ISO-8859-1' }
+
+          i = HTTPInteraction.from_hash(hash)
+          i.request.body.should eq("abc")
+          i.response.body.should eq("abc")
+          i.request.body.encoding.name.should eq("ISO-8859-1")
+          i.response.body.encoding.name.should eq("ISO-8859-1")
+        end
+
+        context 'when the string cannot be encoded as the original encoding' do
+          before do
+            Request.stub(:warn)
+            Response.stub(:warn)
+
+            hash['request']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
+            hash['response']['body']  = { 'string' => "\xFAbc", 'encoding' => 'ISO-8859-1' }
+            expect { "\xFAbc".encode("ISO-8859-1") }.to raise_error(EncodingError)
+          end
+
+          it 'does not force the encoding' do
+            i = HTTPInteraction.from_hash(hash)
+            i.request.body.should eq("\xFAbc")
+            i.response.body.should eq("\xFAbc")
+            i.request.body.encoding.name.should_not eq("ISO-8859-1")
+            i.response.body.encoding.name.should_not eq("ISO-8859-1")
+          end
+
+          it 'prints a warning and informs users of the :preserve_exact_body_bytes option' do
+            Request.should_receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+            Response.should_receive(:warn).with(/ISO-8859-1.*preserve_exact_body_bytes/)
+
+            HTTPInteraction.from_hash(hash)
+          end
+        end
+      end
     end
 
     describe "#to_hash" do
+      before(:each) do
+        VCR.stub_chain(:configuration, :preserve_exact_body_bytes_for?).and_return(false)
+      end
+
       let(:hash) { interaction.to_hash }
 
       it 'returns a nested hash containing all of the pertinent details' do
@@ -138,7 +205,7 @@ module VCR
         hash['request'].should eq({
           'method'  => 'get',
           'uri'     => 'http://foo.com/',
-          'body'    => 'req body',
+          'body'    => body_hash('string', 'req body'),
           'headers' => { "bar" => ["foo"] }
         })
 
@@ -148,11 +215,25 @@ module VCR
             'message'    => 'OK'
           },
           'headers'      => { "foo"     => ["bar"] },
-          'body'         => 'res body',
+          'body'         => body_hash('string', 'res body'),
           'http_version' => '1.1'
         })
       end
 
+      it 'encodes the body as base64 when the configuration is so set' do
+        VCR.stub_chain(:configuration, :preserve_exact_body_bytes_for?).and_return(true)
+        hash['request']['body'].should eq(body_hash('base64_string', Base64.encode64('req body')))
+        hash['response']['body'].should eq(body_hash('base64_string', Base64.encode64('res body')))
+      end
+
+      it "sets the string's original encoding", :if => ''.respond_to?(:encoding) do
+        interaction.request.body.force_encoding('ISO-8859-10')
+        interaction.response.body.force_encoding('ASCII-8BIT')
+
+        hash['request']['body']['encoding'].should eq('ISO-8859-10')
+        hash['response']['body']['encoding'].should eq('ASCII-8BIT')
+      end
+
       def assert_yielded_keys(hash, *keys)
         yielded_keys = []
         hash.each { |k, v| yielded_keys << k }
@@ -166,65 +247,120 @@ module VCR
         assert_yielded_keys hash['response']['status'], 'code', 'message'
       end
     end
+  end
 
-    describe '#filter!' do
-      let(:response_status) { VCR::ResponseStatus.new(200, "OK foo") }
-      let(:body) { "The body foo this is (foo-Foo)" }
-      let(:headers) do {
-        'x-http-foo' => ['bar23', '23foo'],
-        'x-http-bar' => ['foo23', '18']
-      } end
+  describe HTTPInteraction::HookAware do
+    let(:response_status) { VCR::ResponseStatus.new(200, "OK foo") }
+    let(:body) { "The body foo this is (foo-Foo)" }
+    let(:headers) do {
+      'x-http-foo' => ['bar23', '23foo'],
+      'x-http-bar' => ['foo23', '18']
+    } end
+
+    let(:response) do
+      VCR::Response.new(
+        response_status,
+        headers.dup,
+        body.dup,
+        '1.1'
+      )
+    end
 
-      let(:response) do
-        VCR::Response.new(
-          response_status,
-          headers.dup,
-          body.dup,
-          '1.1'
-        )
-      end
+    let(:request) do
+      VCR::Request.new(
+        :get,
+        'http://example-foo.com:80/foo/',
+        body.dup,
+        headers.dup
+      )
+    end
+
+    let(:interaction) { VCR::HTTPInteraction.new(request, response) }
+    subject { HTTPInteraction::HookAware.new(interaction) }
 
-      let(:request) do
-        VCR::Request.new(
-          :get,
-          'http://example-foo.com:80/foo/',
-          body.dup,
-          headers.dup
-        )
+    describe '#ignored?' do
+      it 'returns false by default' do
+        should_not be_ignored
       end
 
-      let(:interaction) { VCR::HTTPInteraction.new(request, response) }
+      it 'returns true when #ignore! has been called' do
+        subject.ignore!
+        should be_ignored
+      end
+    end
 
-      subject { interaction.filter!('foo', 'AAA') }
+    describe '#filter!' do
+      let(:filtered) { subject.filter!('foo', 'AAA') }
 
       it 'does nothing when given a blank argument' do
         expect {
-          interaction.filter!(nil, 'AAA')
-          interaction.filter!('foo', nil)
-          interaction.filter!("", 'AAA')
-          interaction.filter!('foo', "")
+          subject.filter!(nil, 'AAA')
+          subject.filter!('foo', nil)
+          subject.filter!("", 'AAA')
+          subject.filter!('foo', "")
         }.not_to change { interaction }
       end
 
       [:request, :response].each do |part|
         it "replaces the sensitive text in the #{part} header keys and values" do
-          subject.send(part).headers.should eq({
+          filtered.send(part).headers.should eq({
             'x-http-AAA' => ['bar23', '23AAA'],
             'x-http-bar' => ['AAA23', '18']
           })
         end
 
         it "replaces the sensitive text in the #{part} body" do
-          subject.send(part).body.should eq("The body AAA this is (AAA-Foo)")
+          filtered.send(part).body.should eq("The body AAA this is (AAA-Foo)")
         end
       end
 
       it 'replaces the sensitive text in the response status' do
-        subject.response.status.message.should eq('OK AAA')
+        filtered.response.status.message.should eq('OK AAA')
       end
 
       it 'replaces sensitive text in the request URI' do
-        subject.request.uri.should eq('http://example-AAA.com/AAA/')
+        filtered.request.uri.should eq('http://example-AAA.com/AAA/')
+      end
+    end
+  end
+
+  describe Request::Typed do
+    [:uri, :method, :headers, :body].each do |method|
+      it "delegates ##{method} to the request" do
+        request = stub(method => "delegated value")
+        Request::Typed.new(request, :type).send(method).should eq("delegated value")
+      end
+    end
+
+    describe "#type" do
+      it 'returns the initialized type' do
+        Request::Typed.new(stub, :ignored).type.should be(:ignored)
+      end
+    end
+
+    [:ignored, :stubbed, :recordable, :unhandled].each do |type|
+      describe "##{type}?" do
+        it "returns true if the type is set to :#{type}" do
+          Request::Typed.new(stub, type).send("#{type}?").should be_true
+        end
+
+        it "returns false if the type is set to :other" do
+          Request::Typed.new(stub, :other).send("#{type}?").should be_false
+        end
+      end
+    end
+
+    describe "#real?" do
+      [:ignored, :recordable].each do |type|
+        it "returns true if the type is set to :#{type}" do
+          Request::Typed.new(stub, type).should be_real
+        end
+      end
+
+      [:stubbed, :unhandled].each do |type|
+        it "returns false if the type is set to :#{type}" do
+          Request::Typed.new(stub, type).should_not be_real
+        end
       end
     end
   end
@@ -277,25 +413,22 @@ module VCR
       end
     end
 
-    describe "#fiber_aware" do
+    describe Request::FiberAware do
+      subject { Request::FiberAware.new(Request.new) }
+
       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(subject).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)
+        Fiber.should_receive(:yield)
+        lambda(&subject).call
       end
     end if RUBY_VERSION > '1.9'