vcr 0.4.1 → 1.0.0

data/features/record_response.feature

@@ -1,77 +0,0 @@
-Feature: Record response
-  In order to have deterministic, fast tests that do not depend on an internet connection
-  As a TDD/BDD developer
-  I want to record responses for new requests so I can replay them in future test runs
-
-  Scenario: Record a response using VCR.use_cassette
-    Given we do not have a "temp/cassette" cassette
-     When I make an HTTP get request to "http://example.com" within the "temp/cassette" cassette
-     Then the "temp/cassette" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-
-  @record_cassette1
-  Scenario: Record a response using a tagged scenario
-    Given we do not have a "cucumber_tags/record_cassette1" cassette
-      And this scenario is tagged with the vcr cassette tag: "@record_cassette1"
-     When I make an HTTP get request to "http://example.com"
-     Then I can test the scenario cassette's recorded responses in the next scenario, after the cassette has been ejected
-
-  Scenario: Check the recorded response for the previous scenario
-    Given the previous scenario was tagged with the vcr cassette tag: "@record_cassette1"
-     Then the "cucumber_tags/record_cassette1" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-
-  @record_cassette2
-  Scenario: Use both a tagged scenario cassette and a nested cassette within a single step definition
-    Given we do not have a "cucumber_tags/record_cassette2" cassette
-      And we do not have a "temp/nested" cassette
-      And this scenario is tagged with the vcr cassette tag: "@record_cassette2"
-     When I make an HTTP get request to "http://example.com/before_nested"
-      And I make an HTTP get request to "http://example.com/nested" within the "temp/nested" cassette
-      And I make an HTTP get request to "http://example.com/after_nested"
-     Then I can test the scenario cassette's recorded responses in the next scenario, after the cassette has been ejected
-      And the "temp/nested" library file should have a response for "http://example.com/nested" that matches /The requested URL \/nested was not found/
-
-  Scenario: Check the recorded response for the previous scenario
-    Given the previous scenario was tagged with the vcr cassette tag: "@record_cassette2"
-     Then the "cucumber_tags/record_cassette2" library file should have a response for "http://example.com/before_nested" that matches /The requested URL \/before_nested was not found/
-      And the "cucumber_tags/record_cassette2" library file should have a response for "http://example.com/after_nested" that matches /The requested URL \/after_nested was not found/
-
-  Scenario: Make an HTTP request in a cassette with record mode set to :all
-    Given we do not have a "temp/record_all_cassette" cassette
-     When I make an HTTP get request to "http://example.com" within the "temp/record_all_cassette" all cassette
-     Then the "temp/record_all_cassette" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-
-  Scenario: Make an HTTP request in a cassette with record mode set to :none
-    Given we do not have a "temp/record_none_cassette" cassette
-     When I make an HTTP get request to "http://example.com" within the "temp/record_none_cassette" none cassette
-     Then the HTTP get request to "http://example.com" should result in an error that mentions VCR
-      And there should not be a "temp/record_none_cassette" library file
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :new_episodes
-    Given we have a "temp/not_the_real_response" library file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" library file with no previously recorded response for "http://example.com/foo"
-     When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" new_episodes cassette
-     Then the "temp/not_the_real_response" library file should have a response for "http://example.com" that matches /This is not the real response from example\.com/
-      And the "temp/not_the_real_response" library file should have a response for "http://example.com/foo" that matches /The requested URL \/foo was not found/
-
-  Scenario: Record an asynchronous request (such as for mechanize)
-    Given we do not have a "temp/asynchronous" cassette
-     When I make an asynchronous HTTP get request to "http://example.com" within the "temp/asynchronous" new_episodes cassette
-     Then the "temp/asynchronous" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-
-  Scenario: Record a recursive post request
-    Given we do not have a "temp/recursive_post" cassette
-     When I make a recursive HTTP post request to "http://example.com" within the "temp/recursive_post" new_episodes cassette
-     Then the "temp/recursive_post" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-      And the "temp/recursive_post" library file should have exactly 1 response
-
-  Scenario: Make an allowed HTTP request in a cassette with record mode set to :none
-    Given we do not have a "temp/record_none_cassette" cassette
-     When I make an HTTP get request to "http://example.com" within the "temp/record_none_cassette" none cassette, allowing requests matching /example.com/
-     Then the response for "http://example.com" should match /You have reached this web page by typing.*example\.com/
-      And there should not be a "temp/record_none_cassette" library file
-
-  Scenario: Record a request with a block with a return statement
-    Given we do not have a "temp/block_with_a_return" cassette
-     When I make a returning block HTTP get request to "http://example.com" within the "temp/block_with_a_return" new_episodes cassette
-     Then the "temp/block_with_a_return" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/

data/features/replay_recorded_response.feature

@@ -1,69 +0,0 @@
-Feature: Replay recorded response
-  In order to have deterministic, fast tests that do not depend on an internet connection
-  As a TDD/BDD developer
-  I want to replay responses for requests I have previously recorded
-
-  Scenario: Replay recorded response for a request in a VCR.use_cassette block
-    Given the "not_the_real_response" library file has a response for "http://example.com" that matches /This is not the real response from example\.com/
-     When I make an HTTP get request to "http://example.com" within the "not_the_real_response" cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/
-
-  @replay_cassette1
-  Scenario: Replay recorded response for a request within a tagged scenario
-    Given this scenario is tagged with the vcr cassette tag: "@replay_cassette1"
-      And the "cucumber_tags/replay_cassette1" library file has a response for "http://example.com" that matches /This is not the real response from example\.com/
-     When I make an HTTP get request to "http://example.com"
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/
-
-  @replay_cassette2
-  Scenario: Use both a tagged scenario cassette and a nested cassette within a single step definition
-    Given this scenario is tagged with the vcr cassette tag: "@replay_cassette2"
-      And the "cucumber_tags/replay_cassette2" library file has a response for "http://example.com/before_nested" that matches /The before_nested response/
-      And the "nested_replay_cassette" library file has a response for "http://example.com/nested" that matches /The nested response/
-      And the "cucumber_tags/replay_cassette2" library file has a response for "http://example.com/after_nested" that matches /The after_nested response/
-     When I make an HTTP get request to "http://example.com/before_nested"
-      And I make an HTTP get request to "http://example.com/nested" within the "nested_replay_cassette" cassette
-      And I make an HTTP get request to "http://example.com/after_nested"
-     Then the response for "http://example.com/before_nested" should match /The before_nested response/
-      And the response for "http://example.com/nested" should match /The nested response/
-      And the response for "http://example.com/after_nested" should match /The after_nested response/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :all
-    Given we have a "temp/not_the_real_response" library file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" library file with no previously recorded response for "http://example.com/foo"
-     When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" all cassette
-     Then the response for "http://example.com" should match /You have reached this web page by typing.*example\.com/
-      And the response for "http://example.com/foo" should match /The requested URL \/foo was not found/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :none
-    Given we have a "temp/not_the_real_response" library file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" library file with no previously recorded response for "http://example.com/foo"
-     When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" none cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/
-      And the HTTP get request to "http://example.com/foo" should result in an error that mentions VCR
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :new_episodes
-  Given we have a "temp/not_the_real_response" library file with a previously recorded response for "http://example.com"
-    And we have a "temp/not_the_real_response" library file with no previously recorded response for "http://example.com/foo"
-   When I make HTTP get requests to "http://example.com" and "http://example.com/foo" within the "temp/not_the_real_response" new_episodes cassette
-   Then the response for "http://example.com" should match /This is not the real response from example\.com/
-    And the response for "http://example.com/foo" should match /The requested URL \/foo was not found/
-
-  @replay_cassette3
-  Scenario: Replay multiple different recorded responses for requests to the same URL
-    Given this scenario is tagged with the vcr cassette tag: "@replay_cassette3"
-      And the "cucumber_tags/replay_cassette3" library file has a response for "http://example.com" that matches /This is not the real response from example\.com/
-      And the "cucumber_tags/replay_cassette3" library file has a response for "http://example.com" that matches /This is another fake response from example\.com/
-     When I make an HTTP get request to "http://example.com"
-      And I make an HTTP get request to "http://example.com"
-     Then response 1 for "http://example.com" should match /This is not the real response from example\.com/
-      And response 2 for "http://example.com" should match /This is another fake response from example\.com/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Replay a response for an asynchronous request (such as for mechanize)
-    Given the "temp/not_the_real_response" library file has a response for "http://example.com" that matches /This is not the real response from example\.com/
-     When I make a replayed asynchronous HTTP get request to "http://example.com" within the "temp/not_the_real_response" new_episodes cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/

data/features/step_definitions/vcr_steps.rb

@@ -1,144 +0,0 @@
-require 'tmpdir'
-
-module VCRHelpers
-  def have_expected_response(url, regex_str)
-    simple_matcher("a response from #{url} that matches /#{regex_str}/") do |responses|
-      regex = /#{regex_str}/i
-      responses = responses.select { |r| URI.parse(r.uri) == URI.parse(url) }
-      responses.detect { |r| r.response.body =~ regex }
-    end
-  end
-
-  def recorded_interactions_for(cassette_name)
-    yaml_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-    yaml = File.open(yaml_file, 'r') { |f| f.read }
-    interactions = YAML.load(yaml)
-  end
-
-  def capture_response(url)
-    @http_requests ||= Hash.new([])
-    uri = URI.parse(url)
-    path = uri.path.to_s == '' ? '/' : uri.path
-    begin
-      result = yield uri, path
-    rescue => e
-      result = e
-    end
-    @http_requests[url] += [result]
-  end
-
-  def perform_get_with_returning_block(uri, path)
-    Net::HTTP.new(uri.host, uri.port).request(Net::HTTP::Get.new(path, {})) do |response|
-      return response
-    end
-  end
-end
-World(VCRHelpers)
-
-Given /^we do not have a "([^\"]*)" cassette$/ do |cassette_name|
-  fixture_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-  File.exist?(fixture_file).should be_false
-end
-
-Given /^we have a "([^\"]*)" library file with (a|no) previously recorded response for "([^\"]*)"$/ do |file_name, a_or_no, url|
-  fixture_file = File.join(VCR::Config.cassette_library_dir, "#{file_name}.yml")
-  File.exist?(fixture_file).should be_true
-  responses = File.open(fixture_file, 'r') { |f| YAML.load(f.read) }
-  should_method = a_or_no == 'a' ? :should : :should_not
-  responses.map{ |r| URI.parse(r.uri) }.send(should_method, include(URI.parse(url)))
-end
-
-Given /^the "([^\"]*)" library file has a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
-  Given %{we have a "#{cassette_name}" library file with a previously recorded response for "#{url}"}
-  Then %{the "#{cassette_name}" library file should have a response for "#{url}" that matches /#{regex_str}/}
-end
-
-Given /^this scenario is tagged with the vcr cassette tag: "([^\"]+)"$/ do |tag|
-  VCR.current_cucumber_scenario.should be_tagged_with(tag)
-  VCR::CucumberTags.tags.should include(tag)
-end
-
-Given /^the previous scenario was tagged with the vcr cassette tag: "([^\"]*)"$/ do |tag|
-  last_scenario = VCR.completed_cucumber_scenarios.last
-  last_scenario.should_not be_nil
-  last_scenario.should be_tagged_with(tag)
-  VCR::CucumberTags.tags.should include(tag)
-end
-
-When /^I make (?:an )?HTTP get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    Net::HTTP.get_response(uri)
-  end
-end
-
-When /^I make an asynchronous HTTP get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    result = Net::HTTP.new(uri.host, uri.port).request_get(path) { |r| r.read_body { } }
-    result.body.should be_a(Net::ReadAdapter)
-    result
-  end
-end
-
-When /^I make a replayed asynchronous HTTP get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    result_body = ''
-    result = Net::HTTP.new(uri.host, uri.port).request_get(path) { |r| r.read_body { |fragment| result_body << fragment } }
-    result.body.should == result_body
-    result
-  end
-end
-
-When /^I make a recursive HTTP post request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    Net::HTTP.new(uri.host, uri.port).post(path, nil)
-  end
-end
-
-When /^I make a returning block HTTP get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    perform_get_with_returning_block(uri, path)
-  end
-end
-
-When /^I make (.*HTTP (?:get|post)) requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"]*)" ?(#{VCR::Cassette::VALID_RECORD_MODES.join('|')})? cassette(?:, allowing requests matching \/([^\/]+)\/)?$/ do |http_request_type, url1, url2, cassette_name, record_mode, allowed|
-  options = { :record => (record_mode ? record_mode.to_sym : :new_episodes) }
-  options[:allow_real_http] = lambda { |uri| uri.to_s =~ /#{allowed}/ } if allowed.to_s.size > 0
-  urls = [url1, url2].select { |u| u.to_s.size > 0 }
-  VCR.use_cassette(cassette_name, options) do
-    urls.each do |url|
-      When %{I make #{http_request_type} request to "#{url}"}
-    end
-  end
-end
-
-Then /^the "([^\"]*)" library file should have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
-  interactions = recorded_interactions_for(cassette_name)
-  interactions.should have_expected_response(url, regex_str)
-end
-
-Then /^the "([^\"]*)" library file should have exactly (\d+) response$/ do |cassette_name, response_count|
-  interactions = recorded_interactions_for(cassette_name)
-  interactions.should have(response_count.to_i).responses
-end
-
-Then /^I can test the scenario cassette's recorded responses in the next scenario, after the cassette has been ejected$/ do
-  # do nothing...
-end
-
-Then /^the HTTP get request to "([^\"]*)" should result in an error that mentions VCR$/ do |url|
-  result = @http_requests[url][0]
-  result.should be_a(StandardError)
-  result.message.should =~ /VCR/
-end
-
-Then /^(?:the )?response(?: (\d+))? for "([^\"]*)" should match \/(.+)\/$/ do |response_num, url, regex_str|
-  response_num = response_num.to_i || 0
-  response_num -= 1 if response_num > 0 # translate to 0-based array index.
-  regex = /#{regex_str}/i
-  @http_requests[url][response_num].body.should =~ regex
-end
-
-Then /^there should not be a "([^\"]*)" library file$/ do |cassette_name|
-  yaml_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-  File.exist?(yaml_file).should be_false
-end

data/features/support/env.rb

@@ -1,64 +0,0 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'vcr'
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-  Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
-rescue LoadError
-  # ruby-debug wasn't available so neither can the debugging be
-end
-
-require 'spec/expectations'
-
-VCR.config do |c|
-  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', RUBY_VERSION)
-  c.http_stubbing_library = if ENV['HTTP_STUBBING_ADAPTER'].to_s == ''
-    warn "Using fakeweb for VCR's cucumber features since the adapter was not specified.  Set HTTP_STUBBING_ADAPTER to specify."
-    :fakeweb
-  else
-    ENV['HTTP_STUBBING_ADAPTER'].to_sym
-  end
-end
-
-VCR.module_eval do
-  def self.completed_cucumber_scenarios
-    @completed_cucumber_scenarios ||= []
-  end
-
-  class << self
-    attr_accessor :current_cucumber_scenario
-  end
-end
-
-After do |scenario|
-  if raised_error = (@http_requests || {}).values.flatten.detect { |result| result.is_a?(Exception) && result.message !~ /VCR/ }
-    raise raised_error
-  end
-  VCR.completed_cucumber_scenarios << scenario
-end
-
-Before do |scenario|
-  VCR.current_cucumber_scenario = scenario
-  temp_dir = File.join(VCR::Config.cassette_library_dir, 'temp')
-  FileUtils.rm_rf(temp_dir) if File.exist?(temp_dir)
-end
-
-Before('@copy_not_the_real_response_to_temp') do
-  orig_file = File.join(VCR::Config.cassette_library_dir, 'not_the_real_response.yml')
-  temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', 'not_the_real_response.yml')
-  FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
-  FileUtils.cp orig_file, temp_file
-end
-
-at_exit do
-  %w(record_cassette1 record_cassette2).each do |tag|
-    file = File.join(VCR::Config.cassette_library_dir, 'cucumber_tags', "#{tag}.yml")
-    FileUtils.rm_rf(file) if File.exist?(file)
-  end
-end
-
-VCR.cucumber_tags do |t|
-  t.tags '@record_cassette1', '@record_cassette2', :record => :new_episodes
-  t.tags '@replay_cassette1', '@replay_cassette2', '@replay_cassette3', :record => :none
-end

data/lib/vcr/extensions/fake_web.rb

@@ -1,20 +0,0 @@
-require 'fakeweb'
-
-module FakeWeb
-  def self.request_uri(net_http, request)
-    # Copied from: http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L39-52
-    protocol = net_http.use_ssl? ? "https" : "http"
-
-    path = request.path
-    path = URI.parse(request.path).request_uri if request.path =~ /^http/
-
-    if request["authorization"] =~ /^Basic /
-      userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
-      userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
-    else
-      userinfo = ""
-    end
-
-    "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
-  end
-end

data/lib/vcr/extensions/net_read_adapter.rb

@@ -1,22 +0,0 @@
-require 'net/http'
-
-module VCR
-  module NetReadAdapter
-    def new(*args, &block)
-      super.extend Extension
-    end
-
-    module Extension
-      def <<(str)
-        (@__body_for_vcr__ ||= '') << str
-        super
-      end
-
-      def to_yaml(*args)
-        @__body_for_vcr__.to_yaml(*args)
-      end
-    end
-  end
-end
-
-Net::ReadAdapter.extend VCR::NetReadAdapter

data/spec/cassette_spec.rb

@@ -1,213 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe VCR::Cassette do
-  describe '#file' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/file'), :assign_to_cassette_library_dir => true
-
-    it 'combines the cassette_library_dir with the cassette name' do
-      cassette = VCR::Cassette.new('the_file')
-      cassette.file.should == File.join(VCR::Config.cassette_library_dir, 'the_file.yml')
-    end
-
-    it 'strips out disallowed characters so that it is a valid file name with no spaces' do
-      cassette = VCR::Cassette.new("\nthis \t!  is-the_13212_file name")
-      cassette.file.should =~ /#{Regexp.escape('_this_is-the_13212_file_name.yml')}$/
-    end
-
-    it 'keeps any path separators' do
-      cassette = VCR::Cassette.new("dir/file_name")
-      cassette.file.should =~ /#{Regexp.escape('dir/file_name.yml')}$/
-    end
-
-    it 'returns nil if the cassette_library_dir is not set' do
-      VCR::Config.cassette_library_dir = nil
-      cassette = VCR::Cassette.new('the_file')
-      cassette.file.should be_nil
-    end
-  end
-
-  describe '#record_http_interaction' do
-    it 'adds the interaction to #recorded_interactions' do
-      cassette = VCR::Cassette.new(:test_cassette)
-      cassette.recorded_interactions.should == []
-      cassette.record_http_interaction(:the_interaction)
-      cassette.recorded_interactions.should == [:the_interaction]
-    end
-  end
-
-  describe 'on creation' do
-    it 'raises an error with a helpful message when loading an old unsupported cassette' do
-      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}")
-      lambda { VCR::Cassette.new('0_3_1_cassette') }.should raise_error(/The VCR cassette 0_3_1_cassette uses an old format that is now deprecated/)
-    end
-
-    it "raises an error if given an invalid record mode" do
-      lambda { VCR::Cassette.new(:test, :record => :not_a_record_mode) }.should raise_error(ArgumentError)
-    end
-
-    it 'creates a stubs checkpoint on the http_stubbing_adapter' do
-      VCR.http_stubbing_adapter.should_receive(:create_stubs_checkpoint).with('example').once
-      VCR::Cassette.new('example')
-    end
-
-    VCR::Cassette::VALID_RECORD_MODES.each do |mode|
-      it "defaults the record mode to #{mode} when VCR::Config.default_cassette_options[:record] is #{mode}" do
-        VCR::Config.default_cassette_options = { :record => mode }
-        cassette = VCR::Cassette.new(:test)
-        cassette.record_mode.should == mode
-      end
-    end
-
-    { :new_episodes => true, :all => true, :none => false }.each do |record_mode, http_connections_allowed|
-      it "sets http_connections_allowed to #{http_connections_allowed} on the http stubbing adapter when the record mode is #{record_mode}" do
-        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(http_connections_allowed)
-        VCR::Cassette.new(:name, :record => record_mode)
-      end
-    end
-
-    { :new_episodes => true, :all => false, :none => true }.each do |record_mode, load_interactions|
-      it "#{load_interactions ? 'loads' : 'does not load'} the recorded interactions from the library yml file when the record mode is #{record_mode}" do
-        VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-        cassette = VCR::Cassette.new('example', :record => record_mode)
-
-        if load_interactions
-          cassette.should have(3).recorded_interactions
-
-          i1, i2, i3 = *cassette.recorded_interactions
-
-          i1.request.method.should == :get
-          i1.request.uri.should == 'http://example.com:80/'
-          i1.response.body.should =~ /You have reached this web page by typing.+example\.com/
-
-          i2.request.method.should == :get
-          i2.request.uri.should == 'http://example.com:80/foo'
-          i2.response.body.should =~ /foo was not found on this server/
-
-          i3.request.method.should == :get
-          i3.request.uri.should == 'http://example.com:80/'
-          i3.response.body.should =~ /Another example\.com response/
-        else
-          cassette.should have(0).recorded_interactions
-        end
-      end
-
-      it "#{load_interactions ? 'stubs' : 'does not stub'} the recorded requests with the http stubbing adapter when the record mode is #{record_mode}" do
-        VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-
-        if load_interactions
-          VCR.http_stubbing_adapter.should_receive(:stub_requests).with([an_instance_of(VCR::HTTPInteraction)]*3)
-        else
-          VCR.http_stubbing_adapter.should_receive(:stub_requests).never
-        end
-
-        cassette = VCR::Cassette.new('example', :record => record_mode)
-      end
-    end
-  end
-
-  describe '#allow_real_http_requests_to?' do
-    it 'delegates to the :allow_real_http lambda' do
-      [true, false].each do |value|
-        yielded_uri = nil
-        c = VCR::Cassette.new('example', :allow_real_http => lambda { |uri| yielded_uri = uri; value })
-        c.allow_real_http_requests_to?(:the_uri).should == value
-        yielded_uri.should == :the_uri
-      end
-    end
-
-    it 'returns true for localhost requests when the :allow_real_http option is set to :localhost' do
-      c = VCR::Cassette.new('example', :allow_real_http => :localhost)
-      c.allow_real_http_requests_to?(URI('http://localhost')).should be_true
-      c.allow_real_http_requests_to?(URI('http://example.com')).should be_false
-    end
-
-    it 'returns false when no option is set' do
-      c = VCR::Cassette.new('example')
-      c.allow_real_http_requests_to?(URI('http://localhost')).should be_false
-      c.allow_real_http_requests_to?(URI('http://example.com')).should be_false
-    end
-
-    it 'delegates to the default :allow_real_http lambda' do
-      [true, false].each do |value|
-        yielded_uri = nil
-        VCR::Config.default_cassette_options.merge!(:allow_real_http => lambda { |uri| yielded_uri = uri; value })
-        c = VCR::Cassette.new('example')
-        c.allow_real_http_requests_to?(:the_uri).should == value
-        yielded_uri.should == :the_uri
-      end
-
-      VCR::Config.default_cassette_options.merge!(:allow_real_http => :localhost)
-      c = VCR::Cassette.new('example')
-      c.allow_real_http_requests_to?(URI('http://localhost')).should be_true
-      c.allow_real_http_requests_to?(URI('http://example.com')).should be_false
-    end
-  end
-
-  describe '#eject' do
-    temp_dir File.expand_path(File.dirname(__FILE__) + '/fixtures/cassette_spec_eject'), :assign_to_cassette_library_dir => true
-
-    [true, false].each do |orig_http_connections_allowed|
-      it "resets #{orig_http_connections_allowed} on the http stubbing adapter if it was originally #{orig_http_connections_allowed}" do
-        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed?).and_return(orig_http_connections_allowed)
-        cassette = VCR::Cassette.new(:name)
-        VCR.http_stubbing_adapter.should_receive(:http_connections_allowed=).with(orig_http_connections_allowed)
-        cassette.eject
-      end
-    end
-
-    it "writes the recorded interactions to disk as yaml" do
-      recorded_interactions = [
-        VCR::HTTPInteraction.new(:req_sig_1, :response_1),
-        VCR::HTTPInteraction.new(:req_sig_2, :response_2),
-        VCR::HTTPInteraction.new(:req_sig_3, :response_3)
-      ]
-
-      cassette = VCR::Cassette.new(:eject_test)
-      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
-
-      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
-      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_interactions.should == recorded_interactions
-    end
-
-    it "writes the recorded interactions to a subdirectory if the cassette name includes a directory" do
-      recorded_interactions = [VCR::HTTPInteraction.new(:the_request, :the_response)]
-      cassette = VCR::Cassette.new('subdirectory/test_cassette')
-      cassette.stub!(:recorded_interactions).and_return(recorded_interactions)
-
-      lambda { cassette.eject }.should change { File.exist?(cassette.file) }.from(false).to(true)
-      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_interactions.should == recorded_interactions
-    end
-
-    it "writes both old and new recorded interactions to disk" do
-      file = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec/example.yml")
-      FileUtils.cp file, File.join(@temp_dir, 'previously_recorded_interactions.yml')
-      cassette = VCR::Cassette.new('previously_recorded_interactions')
-      cassette.should have(3).recorded_interactions
-      new_recorded_interaction = VCR::HTTPInteraction.new(:the_request, :the_response)
-      cassette.record_http_interaction(new_recorded_interaction)
-      cassette.eject
-      saved_recorded_interactions = File.open(cassette.file, "r") { |f| YAML.load(f.read) }
-      saved_recorded_interactions.should have(4).recorded_interactions
-      saved_recorded_interactions.last.should == new_recorded_interaction
-    end
-  end
-
-  describe '#eject for a cassette with previously recorded interactions' do
-    it "restore the stubs checkpoint on the http stubbing adapter" do
-      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-      cassette = VCR::Cassette.new('example', :record => :none)
-      VCR.http_stubbing_adapter.should_receive(:restore_stubs_checkpoint).with('example')
-      cassette.eject
-    end
-
-    it "does not re-write to disk the previously recorded interactions if there are no new ones" do
-      VCR::Config.cassette_library_dir = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{RUBY_VERSION}/cassette_spec")
-      yaml_file = File.join(VCR::Config.cassette_library_dir, 'example.yml')
-      cassette = VCR::Cassette.new('example', :record => :none)
-      File.should_not_receive(:open).with(cassette.file, 'w')
-      lambda { cassette.eject }.should_not change { File.mtime(yaml_file) }
-    end
-  end
-end