vcr 3.0.3 → 6.1.0

data/spec/lib/vcr/configuration_spec.rb

@@ -1,326 +0,0 @@
-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 }
-
-    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)
-    end
-
-    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)
-      expect(subject.cassette_library_dir).to eq(absolute_dir)
-    end
-  end
-
-  describe '#default_cassette_options' do
-    it 'has a hash with some defaults' do
-      expect(subject.default_cassette_options).to eq({
-        :match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS,
-        :allow_unused_http_interactions => true,
-        :record            => :once,
-        :serialize_with    => :yaml,
-        :persist_with      => :file_system
-      })
-    end
-
-    it "returns #{VCR::RequestMatcherRegistry::DEFAULT_MATCHERS.inspect} for :match_requests_on when other defaults have been set" do
-      subject.default_cassette_options = { :record => :none }
-      expect(subject.default_cassette_options).to include(:match_requests_on => VCR::RequestMatcherRegistry::DEFAULT_MATCHERS)
-    end
-
-    it "returns :once for :record when other defaults have been set" do
-      subject.default_cassette_options = { :erb => :true }
-      expect(subject.default_cassette_options).to include(:record => :once)
-    end
-
-    it "allows defaults to be overriden" do
-      subject.default_cassette_options = { :record => :all }
-      expect(subject.default_cassette_options).to include(:record => :all)
-    end
-
-    it "allows other keys to be set" do
-      subject.default_cassette_options = { :re_record_interval => 10 }
-      expect(subject.default_cassette_options).to include(:re_record_interval => 10)
-    end
-  end
-
-  describe '#register_request_matcher' do
-    it 'registers the given request matcher' do
-      expect {
-        VCR.request_matchers[:custom]
-      }.to raise_error(VCR::UnregisteredMatcherError)
-
-      matcher_run = false
-      subject.register_request_matcher(:custom) { |r1, r2| matcher_run = true }
-      VCR.request_matchers[:custom].matches?(:r1, :r2)
-      expect(matcher_run).to be true
-    end
-  end
-
-  describe '#hook_into' do
-    it 'requires the named library hook' do
-      expect(subject).to receive(:require).with("vcr/library_hooks/fakeweb")
-      expect(subject).to receive(:require).with("vcr/library_hooks/excon")
-      subject.hook_into :fakeweb, :excon
-    end
-
-    it 'raises an error for unsupported stubbing libraries' do
-      expect {
-        subject.hook_into :unsupported_library
-      }.to raise_error(ArgumentError, /unsupported_library is not a supported VCR HTTP library hook/i)
-    end
-
-    it 'invokes the after_library_hooks_loaded hooks' do
-      called = false
-      subject.after_library_hooks_loaded { called = true }
-      subject.hook_into :fakeweb
-      expect(called).to be true
-    end
-  end
-
-  describe '#ignore_hosts' do
-    it 'delegates to the current request_ignorer instance' do
-      expect(VCR.request_ignorer).to receive(:ignore_hosts).with('example.com', 'example.net')
-      subject.ignore_hosts 'example.com', 'example.net'
-    end
-  end
-
-  describe '#ignore_localhost=' do
-    it 'delegates to the current request_ignorer instance' do
-      expect(VCR.request_ignorer).to receive(:ignore_localhost=).with(true)
-      subject.ignore_localhost = true
-    end
-  end
-
-  describe '#ignore_request' do
-    let(:uri){ URI('http://foo.com') }
-
-    it 'registers the given block with the request ignorer' do
-      block_called = false
-      subject.ignore_request { |r| block_called = true }
-      VCR.request_ignorer.ignore?(double(:parsed_uri => uri))
-      expect(block_called).to be true
-    end
-  end
-
-  describe '#allow_http_connections_when_no_cassette=' do
-    [true, false].each do |val|
-      it "sets the allow_http_connections_when_no_cassette to #{val} when set to #{val}" do
-        subject.allow_http_connections_when_no_cassette = val
-        expect(subject.allow_http_connections_when_no_cassette?).to eq(val)
-      end
-    end
-  end
-
-  describe "request/configuration interactions", :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
-
-      expect(before_record_req).not_to respond_to(:type)
-      expect(before_request_req).to respond_to(:type)
-    end unless (RUBY_VERSION =~ /^1\.8/ || RUBY_INTERPRETER == :jruby)
-
-    specify 'the filter_sensitive_data option works even when it modifies the URL in a way that makes it an invalid URI' do
-      VCR.configure do |c|
-        c.filter_sensitive_data('<HOST>') { 'localhost' }
-      end
-
-      2.times do
-        VCR.use_cassette("example") do
-          ::Net::HTTP.get_response(URI("http://localhost:#{VCR::SinatraApp.port}/foo"))
-        end
-      end
-    end
-  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, double, double(:tags => []))
-        expect(called).to be false
-        VCR.configuration.invoke_hook(hook_type, double, double(:tags => [:my_tag]))
-        expect(called).to be true
-      end
-    end
-  end
-
-  %w[ filter_sensitive_data define_cassette_placeholder ].each do |method|
-    describe "##{method}" do
-      let(:interaction) { double('interaction').as_null_object }
-      before(:each) { allow(interaction).to receive(: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' })
-        expect(interaction).to receive(:filter!).with('bar', 'foo')
-        subject.invoke_hook(:before_record, interaction, double.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' })
-        expect(interaction).to receive(:filter!).with('foo', 'bar')
-        subject.invoke_hook(:before_playback, interaction, double.as_null_object)
-      end
-
-      it 'tags the before_record hook when given a tag' do
-        expect(subject).to receive(:before_record).with(:my_tag)
-        subject.send(method, 'foo', :my_tag) { 'bar' }
-      end
-
-      it 'tags the before_playback hook when given a tag' do
-        expect(subject).to receive(:before_playback).with(:my_tag)
-        subject.send(method, 'foo', :my_tag) { 'bar' }
-      end
-
-      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, double.as_null_object)
-        expect(yielded_interaction).to 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, double.as_null_object)
-        expect(yielded_interaction).to equal(interaction)
-      end
-    end
-  end
-
-  describe "#after_http_request" do
-    let(:raw_request) { VCR::Request.new }
-    let(:response)    { VCR::Response.new }
-
-    def request(type)
-      VCR::Request::Typed.new(raw_request, type)
-    end
-
-    it 'handles symbol request predicate filters properly' do
-      yielded = false
-      subject.after_http_request(:stubbed_by_vcr?) { |req| yielded = true }
-      subject.invoke_hook(:after_http_request, request(:stubbed_by_vcr), response)
-      expect(yielded).to be true
-
-      yielded = false
-      subject.invoke_hook(:after_http_request, request(:ignored), response)
-      expect(yielded).to be false
-    end
-  end
-
-  describe "#around_http_request, when called on ruby 1.8" do
-    it 'raises an error since fibers are not available' do
-      expect {
-        subject.around_http_request { }
-      }.to raise_error(/requires fibers, which are not available/)
-    end
-  end if RUBY_VERSION < '1.9'
-
-  describe "#cassette_serializers" do
-    let(:custom_serializer) { double }
-    it 'allows a custom serializer to be registered' do
-      expect { subject.cassette_serializers[:custom] }.to raise_error(ArgumentError)
-      subject.cassette_serializers[:custom] = custom_serializer
-      expect(subject.cassette_serializers[:custom]).to be(custom_serializer)
-    end
-  end
-
-  describe "#cassette_persisters" do
-    let(:custom_persister) { double }
-    it 'allows a custom persister to be registered' do
-      expect { subject.cassette_persisters[:custom] }.to raise_error(ArgumentError)
-      subject.cassette_persisters[:custom] = custom_persister
-      expect(subject.cassette_persisters[:custom]).to be(custom_persister)
-    end
-  end
-
-  describe "#uri_parser=" do
-    let(:custom_parser) { double }
-    it 'allows a custom uri parser to be set' do
-      subject.uri_parser = custom_parser
-      expect(subject.uri_parser).to eq(custom_parser)
-    end
-
-    it "uses Ruby's standard library `URI` as a default" do
-      expect(subject.uri_parser).to eq(URI)
-    end
-  end
-
-  describe "#preserve_exact_body_bytes_for?" do
-    def message_for(body)
-      double(:body => body)
-    end
-
-    context "default hook" do
-      it "returns false when there is no current cassette" do
-        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to 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')
-        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to 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)
-        expect(subject.preserve_exact_body_bytes_for?(message_for "string")).to be true
-      end
-    end
-
-    it "returns true when the configured block returns true" do
-      subject.preserve_exact_body_bytes { |msg| msg.body == "a" }
-      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be true
-      expect(subject.preserve_exact_body_bytes_for?(message_for "b")).to 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 }
-      expect(subject.preserve_exact_body_bytes_for?(message_for "a")).to be true
-      expect(called_hooks).to 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|
-        expect(cassette).to be_a(VCR::Cassette)
-        message = double(:message)
-
-        yielded_objects = nil
-        subject.preserve_exact_body_bytes { |a, b| yielded_objects = [a, b] }
-        subject.preserve_exact_body_bytes_for?(message)
-        expect(yielded_objects).to eq([message, cassette])
-      end
-    end
-  end
-
-  describe "#configure_rspec_metadata!" do
-    it "only configures the underlying metadata once, no matter how many times it is called" do
-      expect(VCR::RSpec::Metadata).to receive(:configure!).once
-      VCR.configure do |c|
-        c.configure_rspec_metadata!
-      end
-      VCR.configure do |c|
-        c.configure_rspec_metadata!
-      end
-    end
-  end
-end

data/spec/lib/vcr/deprecations_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe VCR, 'deprecations', :disable_warnings do
-  describe ".config" do
-    it 'delegates to VCR.configure' do
-      expect(VCR).to receive(:configure)
-      VCR.config { }
-    end
-
-    it 'yields the configuration object' do
-      config_object = nil
-      VCR.config { |c| config_object = c }
-      expect(config_object).to be(VCR.configuration)
-    end
-
-    it 'prints a deprecation warning' do
-      expect(VCR).to receive(:warn).with(/VCR.config.*deprecated/i)
-
-      VCR.config { }
-    end
-  end
-
-  describe "Config" do
-    it 'returns the same object referenced by VCR.configuration' do
-      expect(VCR::Config).to be(VCR.configuration)
-    end
-
-    it 'prints a deprecation warning' do
-      expect(VCR).to receive(:warn).with(/VCR::Config.*deprecated/i)
-
-      VCR::Config
-    end
-
-    it 'preserves the normal undefined constant behavior' do
-      expect {
-        VCR::SomeUndefinedConstant
-      }.to raise_error(NameError)
-    end
-  end
-
-  describe "Cassette::MissingERBVariableError" do
-    it 'returns VCR::Errors::MissingERBVariableError' do
-      expect(VCR::Cassette::MissingERBVariableError).to be(VCR::Errors::MissingERBVariableError)
-    end
-
-    it 'prints a deprecation warning' do
-      expect(VCR::Cassette).to receive(:warn).with(/VCR::Cassette::MissingERBVariableError.*deprecated/i)
-
-      VCR::Cassette::MissingERBVariableError
-    end
-
-    it 'preserves the normal undefined constant behavior' do
-      expect {
-        VCR::Cassette::SomeUndefinedConstant
-      }.to raise_error(NameError)
-    end
-  end
-
-  describe "VCR.configure { |c| c.stub_with ... }" do
-    it 'delegates to #hook_into' do
-      expect(VCR.configuration).to receive(:hook_into).with(:fakeweb, :excon)
-      VCR.configure { |c| c.stub_with :fakeweb, :excon }
-    end
-
-    it 'prints a deprecation warning' do
-      expect(VCR.configuration).to receive(:warn).with(/stub_with.*deprecated/i)
-      VCR.configure { |c| c.stub_with :fakeweb, :excon }
-    end
-  end
-
-  describe "VCR::Middleware::Faraday" do
-    it 'prints a deprecation warning when passed a block' do
-      expect(Kernel).to receive(:warn).with(/Passing a block .* is deprecated/)
-      VCR::Middleware::Faraday.new(double) { }
-    end
-  end
-
-  describe "VCR::RSpec::Macros" do
-    it 'prints a deprecation warning' do
-      expect(Kernel).to receive(:warn).with(/VCR::RSpec::Macros is deprecated/)
-      Class.new.extend(VCR::RSpec::Macros)
-    end
-  end
-end
-

data/spec/lib/vcr/errors_spec.rb

@@ -1,178 +0,0 @@
-require 'spec_helper'
-
-module VCR
-  module Errors
-    describe UnhandledHTTPRequestError do
-      def message_for(request_values = {})
-        described_class.new(request_with request_values).message
-      end
-      alias message message_for
-
-      def request_with(values)
-        VCR::Request.new.tap do |request|
-          values.each do |name, value|
-            request.send("#{name}=", value)
-          end
-        end
-      end
-
-      it 'identifies the request by method and URI' do
-        expect(message_for(:method => :post, :uri => 'http://foo.com/')).to include(
-          'POST http://foo.com/'
-        )
-      end
-
-      context 'when there is no cassette' do
-        it 'identifies the request by its body when the default_cassette_options include the body in the match_requests_on option' do
-          VCR.configuration.default_cassette_options[:match_requests_on] = [:body]
-
-          expect(message_for(:body => 'param=val1')).to include(
-            "Body: param=val1"
-          )
-        end
-
-        it 'mentions that there is no cassette' do
-          expect(message).to include('There is currently no cassette in use.')
-        end
-
-        it 'mentions that the request can be recorded by inserting a cassette' do
-          expect(message).to match(/record this request and play it back.*VCR.use_cassette/m)
-        end
-
-        it 'mentions the allow_http_connections_when_no_cassette option' do
-          expect(message).to include('allow_http_connections_when_no_cassette')
-        end
-
-        it 'mentions that the request can be ignored' do
-          expect(message).to include('set an `ignore_request` callback')
-        end
-
-        it 'does not double-insert the asterisks for the bullet points' do
-          expect(message).not_to match(/\s+\*\s+\*/)
-        end
-
-        it 'mentions the debug logging configuration option' do
-          expect(message).to include('debug_logger')
-        end
-      end
-
-      context 'when there are cassettes' do
-        it 'identifies the request by its body when the match_requests_on option includes the body' do
-          VCR.use_cassette('example', :match_requests_on => [:body]) do
-            expect(message_for(:body => 'param=val1')).to include(
-              "Body: param=val1"
-            )
-          end
-        end
-
-        it 'does not identify the request by its body when the cassette match_requests_on option does not include the body but the default_cassette_options do' do
-          VCR.configuration.default_cassette_options[:match_requests_on] = [:body]
-          VCR.use_cassette('example', :match_requests_on => [:uri]) do
-            expect(message_for(:body => 'param=val1')).to_not match(/body/i)
-          end
-        end
-
-        it 'mentions the details about the single cassette when there is one cassette' do
-          VCR.use_cassette('example') do
-            expect(message).to match(/VCR is currently using the following cassette:.+example.yml/m)
-          end
-        end
-
-        it 'mentions the details about all cassettes when there are a few cassettes' do
-          VCR.use_cassette('example') do
-            VCR.use_cassette('sample') do
-              expect(message).to match(/VCR are currently using the following cassettes:.+sample.yml.+example.yml/m)
-            end
-          end
-        end
-
-        it 'mentions that :new_episodes can be used to record the request' do
-          VCR.use_cassette('example') do
-            expect(message).to include('use the :new_episodes record mode')
-          end
-        end
-
-        it 'mentions that :once does not allow a cassette to be re-recorded' do
-          VCR.use_cassette('example', :record => :once) do
-            expect(message).to include('(:once) does not allow new requests to be recorded')
-          end
-        end
-
-        it 'mentions that :none does not allow any recording' do
-          VCR.use_cassette('example', :record => :none) do
-            expect(message).to include('(:none) does not allow requests to be recorded')
-          end
-        end
-
-        it 'does not mention the :once or :none record modes if using the :new_episodes record mode' do
-          VCR.use_cassette('example', :record => :new_episodes) do
-            expect(message).not_to include(':once', ':none')
-          end
-        end
-
-        it 'does not mention the :once or :none record modes if using the :new_episodes record mode at least in one cassette' do
-          VCR.use_cassette('example', :record => :new_episodes) do
-            VCR.use_cassette('sample') do
-              expect(message).not_to include('current record mode (:once)', 'current record mode (:none)')
-            end
-          end
-        end
-
-        it 'mentions :allow_playback_repeats if the cassette has a used matching interaction' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
-            allow(cassette.http_interactions).to receive(:has_used_interaction_matching?).and_return(true)
-            expect(message).to include('allow_playback_repeats')
-          end
-        end
-
-        it 'does not mention :allow_playback_repeats if the cassette does not have a used matching interaction' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:has_used_interaction_matching?)
-            allow(cassette.http_interactions).to receive(:has_used_interaction_matching?).and_return(false)
-            expect(message).not_to include('allow_playback_repeats')
-          end
-        end
-
-        it 'does not mention using a different :match_requests_on option when there are no remaining unused interactions' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
-            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(0)
-            expect(message).not_to include('match_requests_on cassette option')
-          end
-        end
-
-        it 'mentions using a different :match_requests_on option when there are some remaining unused interactions' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
-            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(1)
-            expect(message).to include('match_requests_on cassette option')
-          end
-        end
-
-        it 'uses the singular (HTTP interaction) when there is only 1 left' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
-            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(1)
-            expect(message).to include('1 HTTP interaction ')
-          end
-        end
-
-        it 'uses the plural (HTTP interactions) when there is more than 1 left' do
-          VCR.use_cassette('example') do |cassette|
-            expect(cassette.http_interactions).to respond_to(:remaining_unused_interaction_count)
-            allow(cassette.http_interactions).to receive(:remaining_unused_interaction_count).and_return(2)
-            expect(message).to include('2 HTTP interactions ')
-          end
-        end
-
-        it 'mentions the debug logging configuration option' do
-          VCR.use_cassette('example', :record => :new_episodes) do
-            expect(message).to include('debug_logger')
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/lib/vcr/extensions/net_http_response_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe VCR::Net::HTTPResponse do
-  def self.it_allows_the_body_to_be_read(expected_regex)
-    it 'allows the body to be read using #body' do
-      expect(response.body.to_s).to match expected_regex
-    end
-
-    it 'allows the body to be read using #read_body' do
-      expect(response.read_body.to_s).to match expected_regex
-    end
-
-    it 'allows the body to be read using #read_body with a block' do
-      yielded_body = ''
-      response { |r| r.read_body { |s| yielded_body << s.to_s } }
-      expect(yielded_body).to match expected_regex
-    end
-
-    it 'allows the body to be read by passing a destination string to #read_body' do
-      dest = ''
-      ret_val = response { |r| r.read_body(dest) }.body
-      expect(dest.to_s).to match expected_regex
-      expect(ret_val.to_s).to eq(dest)
-    end
-
-    it 'raises an ArgumentError if both a destination string and a block is given to #read_body' do
-      dest = ''
-      expect { response { |r| r.read_body(dest) { |s| } } }.to raise_error(ArgumentError, 'both arg and block given for HTTP method')
-    end
-
-    it 'raises an IOError when #read_body is called twice with a block' do
-      response { |r| r.read_body { |s| } }
-      expect { response { |r| r.read_body { |s| } } }.to raise_error(IOError, /read_body called twice/)
-    end
-
-    it 'raises an IOError when #read_body is called twice with a destination string' do
-      dest = ''
-      response { |r| r.read_body(dest) }
-      expect { response { |r| r.read_body(dest) } }.to raise_error(IOError, /read_body called twice/)
-    end
-  end
-
-  { :get => /GET to root/, :head => /\A\z/ }.each do |http_verb, expected_body_regex|
-    context "for a #{http_verb.to_s.upcase} request" do
-      let(:http_verb_method) { :"request_#{http_verb}" }
-
-      def response(&block)
-        if defined?(@response) && block
-          block.call(@response)
-          return @response
-        end
-
-        @response ||= begin
-          http = Net::HTTP.new('localhost', VCR::SinatraApp.port)
-          res = http.send(http_verb_method, '/', &block)
-          expect(res).not_to be_a(VCR::Net::HTTPResponse)
-          expect(res).not_to be_a(::Net::WebMockHTTPResponse)
-          res
-        end
-      end
-
-      context 'when the body has not already been read' do
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-
-      context 'when the body has already been read using #read_body and a dest string' do
-        before(:each) do
-          dest = ''
-          response { |res| res.read_body(dest) }
-          response.extend VCR::Net::HTTPResponse
-        end
-
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-
-      context 'when the body has already been read using #body' do
-        before(:each) do
-          response.body
-          response.extend VCR::Net::HTTPResponse
-        end
-
-        it_allows_the_body_to_be_read(expected_body_regex)
-      end
-    end
-  end
-end