vcr 1.3.1 → 1.3.2

data/features/fixtures/vcr_cassettes/not_1.9.1/replay_localhost_cassette.yml

@@ -1,32 +0,0 @@
---- 
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: http://localhost/
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      etag: 
-      - "\"24ec5-1b6-4059a80bfd280\""
-      last-modified: 
-      - Tue, 15 Nov 2005 13:24:10 GMT
-      connection: 
-      - Keep-Alive
-      content-type: 
-      - text/html; charset=UTF-8
-      date: 
-      - Thu, 25 Feb 2010 15:22:32 GMT
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "438"
-      age: 
-      - "2643"
-      accept-ranges: 
-      - bytes
-    body: This is a fake response.
-    http_version: "1.1"

data/features/http_client.feature

@@ -1,16 +0,0 @@
-@httpclient
-Feature: HTTPClient
-  In order to have deterministic, fast tests that do not depend on an internet connection
-  As a TDD/BDD developer
-  I want VCR to work with asynchronous HTTPClient requests
-
-  Scenario: Record an asynchronous request
-    Given we do not have a "temp/asynchronous" cassette
-     When I make an asynchronous HTTPClient get request to "http://example.com" while using the "temp/asynchronous" 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/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Replay a response for an asynchronous request
-    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 an asynchronous HTTPClient get request to "http://example.com" while using the "temp/not_the_real_response" cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/

data/features/net_http.feature

@@ -1,38 +0,0 @@
-@net_http
-Feature: Net::HTTP
-  In order to have deterministic, fast tests that do not depend on an internet connection
-  As a TDD/BDD developer
-  I want to use VCR with Net::HTTP
-
-  Scenario: Record an asynchronous request (such as for mechanize)
-    Given we do not have a "temp/asynchronous" cassette
-     When I make an asynchronous Net::HTTP get request to "http://example.com" while using the "temp/asynchronous" 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/
-
-  @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 Net::HTTP get request to "http://example.com" while using the "temp/not_the_real_response" cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/
-
-  Scenario: Record a recursive post request
-    Given we do not have a "temp/recursive_post" cassette
-     When I make a recursive Net::HTTP post request to "http://example.com" while using the "temp/recursive_post" 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: 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 Net::HTTP get request to "http://example.com" while using the "temp/block_with_a_return" 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/
-
-  Scenario: Record a request made with open uri
-    Given we do not have a "temp/open_uri" cassette
-     When I make an open uri Net::HTTP get request to "http://example.com" while using the "temp/open_uri" cassette
-     Then the "temp/open_uri" library file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: Replay a response for an open uri request
-    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 an open uri Net::HTTP get request to "http://example.com" while using the "temp/not_the_real_response" cassette
-     Then the response for "http://example.com" should match /This is not the real response from example\.com/

data/features/record_response.feature

@@ -1,95 +0,0 @@
-@all_http_libs
-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/" while using 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/
-      And the "temp/cassette" library file should have normalized headers for all recorded interactions
-
-  @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" while using 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 when the cassette does not already exist
-    Given we do not have a "temp/record_all_cassette" cassette
-     When I make an HTTP get request to "http://example.com/" while using the "temp/record_all_cassette" cassette using cassette options: { :record => :all }
-     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/
-
-  @copy_record_all_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :all when the cassette already exists
-    Given the "temp/record_all" library file has a response for "http://example.com/a" that matches /a response 1/
-      And the "temp/record_all" library file has a response for "http://example.com/a" that matches /a response 2/
-      And the "temp/record_all" library file has a response for "http://example.com/b" that matches /b response 1/
-      And the "temp/record_all" library file has a response for "http://example.com/b" that matches /b response 2/
-     When I make an HTTP get request to "http://example.com/a" while using the "temp/record_all" cassette using cassette options: { :record => :all }
-     Then the "temp/record_all" library file should have a response for "http://example.com/a" that matches /The requested URL \/a was not found/
-      And the "temp/record_all" library file should not have a response for "http://example.com/a" that matches /a response 1/
-      And the "temp/record_all" library file should not have a response for "http://example.com/a" that matches /a response 2/
-      And the "temp/record_all" library file should have a response for "http://example.com/b" that matches /b response 1/
-      And the "temp/record_all" library file should have a response for "http://example.com/b" that matches /b response 2/
-
-  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/" while using the "temp/record_none_cassette" cassette using cassette options: { :record => :none }
-     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" while using the "temp/not_the_real_response" 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/
-
-  @spawns_localhost_server
-  Scenario: Ignore localhost setting allows localhost requests and does not record them
-    Given we do not have a "temp/localhost" cassette
-      And the ignore_localhost config setting is set to true
-      And a rack app is running on localhost that returns "hello world" for all requests
-     When I make an HTTP get request to the localhost rack app while using the "temp/localhost" cassette
-     Then the response for the localhost rack app should match /hello world/
-      And there should not be a "temp/localhost" library file
-
-  @copy_not_the_real_response_to_temp
-  Scenario: The response is not automatically recorded when not enough time has passed
-    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/
-      And 6 days have passed since the "temp/not_the_real_response" library file last changed
-     When I make an HTTP get request to "http://example.com/" while using the "temp/not_the_real_response" cassette using cassette options: { :record => :none, :re_record_interval => 7.days }
-     Then the response for "http://example.com/" should match /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/" that matches /This is not the real response from example.com/
-
-  @copy_not_the_real_response_to_temp
-  Scenario: The response is automatically recorded when enough time has passed
-    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/
-      And 8 days have passed since the "temp/not_the_real_response" library file last changed
-     When I make an HTTP get request to "http://example.com/" while using the "temp/not_the_real_response" cassette using cassette options: { :record => :none, :re_record_interval => 7.days }
-     Then the response for "http://example.com/" should match /You have reached this web page by typing.*example\.com/
-      And the "temp/not_the_real_response" 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,96 +0,0 @@
-@all_http_libs
-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/" while using 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" while using 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" while using the "temp/not_the_real_response" cassette using cassette options: { :record => :all }
-     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" while using the "temp/not_the_real_response" cassette using cassette options: { :record => :none }
-     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" while using the "temp/not_the_real_response" 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/
-
-  @regex_cassette
-  Scenario: Replay a cassette with a regex URI
-    Given this scenario is tagged with the vcr cassette tag: "@regex_cassette"
-      And the "cucumber_tags/regex_cassette" library file has a response for /example\.com\/reg/ that matches /This is the response from the regex cassette/
-     When I make an HTTP get request to "http://example.com/regex1"
-      And I make an HTTP get request to "http://example.com/regex2"
-      And I make an HTTP get request to "http://example.com/something_else"
-     Then the response for "http://example.com/regex1" should match /This is the response from the regex cassette/
-      And the response for "http://example.com/regex2" should match /This is the response from the regex cassette/
-      And the HTTP get request to "http://example.com/something_else" should result in an error that mentions VCR
-
-  Scenario: Replay recorded erb response
-    Given the "erb_cassette" library file has a response for "http://example.com/embedded_ruby_code" that matches /Some embedded ruby code[\S\s]*The value of some_variable is/
-     When I make an HTTP get request to "http://example.com/embedded_ruby_code" while using the "erb_cassette" cassette using cassette options: { :record => :none, :erb => { :some_variable => 'foo-bar' } }
-     Then the response for "http://example.com/embedded_ruby_code" should match /Some embedded ruby code: 7[\S\s]*The value of some_variable is: foo-bar/
-
-  @create_replay_localhost_cassette @spawns_localhost_server
-  Scenario: Replay recorded localhost response with ignore_localhost = false
-    Given the ignore_localhost config setting is set to false
-      And the "temp/replay_localhost_cassette" library file has a response for localhost that matches /This is a fake response/
-      And a rack app is running on localhost that returns "localhost response" for all requests
-     When I make an HTTP get request to the localhost rack app while using the "temp/replay_localhost_cassette" cassette
-     Then the response for the localhost rack app should match /This is a fake response/
-
-  @create_replay_localhost_cassette @spawns_localhost_server
-  Scenario: Replay recorded localhost response with ignore_localhost = true
-    Given the ignore_localhost config setting is set to true
-      And the "temp/replay_localhost_cassette" library file has a response for localhost that matches /This is a fake response/
-      And a rack app is running on localhost that returns "localhost response" for all requests
-     When I make an HTTP get request to the localhost rack app while using the "temp/replay_localhost_cassette" cassette
-     Then the response for the localhost rack app should match /localhost response/

data/features/rspec.feature

@@ -1,100 +0,0 @@
-@fakeweb
-Feature: RSpec integration
-  In order to easily use VCR with RSpec
-  As a user of both VCR and RSpec
-  I want a simple macro that uses a cassette for an example group
-
-  Scenario: `use_vcr_cassette` macro for RSpec 2
-    Given the following files do not exist:
-        | cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml |
-        | cassettes/net_http_example.yml                                        |
-      And a file named "use_vcr_cassette_for_rspec_2_spec.rb" with:
-      """
-      require 'vcr'
-
-      VCR.config do |c|
-        c.cassette_library_dir     = 'cassettes'
-        c.http_stubbing_library    = :fakeweb
-        c.default_cassette_options = { :record => :new_episodes }
-      end
-
-      RSpec.configure do |c|
-        c.extend VCR::RSpec::Macros
-      end
-
-      describe "VCR-RSpec integration" do
-        def make_http_request
-          Net::HTTP.get_response('example.com', '/').body
-        end
-
-        context "without an explicit cassette name" do
-          use_vcr_cassette
-
-          it 'records an http request' do
-            make_http_request.should =~ /You have reached this web page by typing.*example\.com/
-          end
-        end
-
-        context "with an explicit cassette name" do
-          use_vcr_cassette "net_http_example"
-
-          it 'records an http request' do
-            make_http_request.should =~ /You have reached this web page by typing.*example\.com/
-          end
-        end
-      end
-      """
-    When I run "rspec ./use_vcr_cassette_for_rspec_2_spec.rb"
-    Then the output should contain "2 examples, 0 failures"
-     And the file "cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "You have reached this web page by typing"
-     And the file "cassettes/net_http_example.yml" should contain "You have reached this web page by typing"
-
-  Scenario: `use_vcr_cassette` macro for RSpec 1
-    Given the following files do not exist:
-        | cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml |
-        | cassettes/net_http_example.yml                                        |
-      And a file named "use_vcr_cassette_for_rspec_1_spec.rb" with:
-      """
-      $LOAD_PATH.unshift(File.join(%w[ .. .. vendor rspec-1 lib ]))
-
-      require 'spec'
-      require 'spec/autorun'
-
-      require 'vcr'
-
-      VCR.config do |c|
-        c.cassette_library_dir     = 'cassettes'
-        c.http_stubbing_library    = :fakeweb
-        c.default_cassette_options = { :record => :new_episodes }
-      end
-
-      Spec::Runner.configure do |c|
-        c.extend VCR::RSpec::Macros
-      end
-
-      describe "VCR-RSpec integration" do
-        def make_http_request
-          Net::HTTP.get_response('example.com', '/').body
-        end
-
-        context "without an explicit cassette name" do
-          use_vcr_cassette
-
-          it 'records an http request' do
-            make_http_request.should =~ /You have reached this web page by typing.*example\.com/
-          end
-        end
-
-        context "with an explicit cassette name" do
-          use_vcr_cassette "net_http_example"
-
-          it 'records an http request' do
-            make_http_request.should =~ /You have reached this web page by typing.*example\.com/
-          end
-        end
-      end
-      """
-    When I run "ruby -I'../../lib' ./use_vcr_cassette_for_rspec_1_spec.rb"
-    Then the output should contain "2 examples, 0 failures"
-     And the file "cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "You have reached this web page by typing"
-     And the file "cassettes/net_http_example.yml" should contain "You have reached this web page by typing"

data/features/step_definitions/http_client_steps.rb

@@ -1,7 +0,0 @@
-When /^I make an asynchronous HTTPClient get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    connection = HTTPClient.new.get_async(uri)
-    connection.join
-    connection.pop
-  end
-end

data/features/step_definitions/net_http_steps.rb

@@ -1,49 +0,0 @@
-require 'open-uri'
-
-module NetHTTPHelpers
-  def perform_net_http_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(NetHTTPHelpers)
-
-When /^I make an asynchronous Net::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 Net::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 } }
-    def result_body.body; self; end # make the string a fake response (so response.body can be called on it)
-    result_body
-  end
-end
-
-When /^I make a recursive Net::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 Net::HTTP get request to "([^\"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    perform_net_http_get_with_returning_block(uri, path)
-  end
-end
-
-When /^I make an open uri Net::HTTP get request to "([^"]*)"$/ do |url|
-  capture_response(url) do |uri, path|
-    result = open(url)
-    # #open returns a StringIO rather than a Net::HTTPResponse, so we add #body to make it conform to the same interface
-    def result.body; read; end
-    result
-  end
-end
-

data/features/step_definitions/vcr_steps.rb

@@ -1,252 +0,0 @@
-require 'tmpdir'
-
-RSpec::Matchers.define :have_expected_response do |regex_str, request_attributes|
-  def matched_responses(responses, request_attributes)
-    url, request_body, request_headers = request_attributes[:url], request_attributes[:request_body], request_attributes[:request_headers]
-
-    selector = case url
-      when String then lambda { |r| URI.parse(r.uri) == URI.parse(url) }
-      when Regexp then lambda { |r| r.uri == url }
-      else raise ArgumentError.new("Unexpected url: #{url.class.to_s}: #{url.inspect}")
-    end
-
-    matched = responses.select(&selector)
-
-    if request_body
-      matched = matched.select { |r| r.request.body == request_body }
-    end
-
-    (request_headers || {}).each do |r_key, r_val|
-      matched = matched.select do |r|
-        r.request.headers.any? { |k, v| k.downcase == r_key.downcase && v == [r_val] }
-      end
-    end
-
-    matched
-  end
-
-  match do |responses|
-    regex = /#{regex_str}/i
-    matched_responses(responses, request_attributes).detect { |r| r.response.body =~ regex }
-  end
-
-  failure_message_for_should do |responses|
-    url = request_attributes[:url]
-    responses = matched_responses(responses, request_attributes)
-    response_bodies = responses.map { |r| r.response.body }
-    "expected a response for #{url.inspect} to match /#{regex_str}/.  Responses for #{url.inspect}:\n\n #{response_bodies.join("\n\n")}"
-  end
-end
-
-RSpec::Matchers.define :be_tagged_with do |tag|
-  match do |scenario|
-    scenario.source_tag_names.include?(tag)
-  end
-
-  failure_message_for_should do |scenario|
-    "expected scenario to be tagged with #{tag}.  Tags: #{scenario.source_tag_names.inspect}"
-  end
-end
-
-RSpec::Matchers.define :have_normalized_headers do
-  match do |object|
-    headers = object.headers
-    headers.is_a?(Hash) &&
-      headers.keys.map { |k| k.downcase } == headers.keys &&
-      headers.values.all? { |val| val.is_a?(Array) }
-  end
-
-  failure_message_for_should do |object|
-    "expected headers to be normalized to have lower cased keys and arrays as values.  Actual headers: #{object.headers.inspect}"
-  end
-end
-
-module VCRHelpers
-  def static_rack_server(response_string)
-    orig_ignore_localhost = VCR.http_stubbing_adapter.ignore_localhost?
-    VCR.http_stubbing_adapter.ignore_localhost = true
-
-    begin
-      VCR::LocalhostServer::STATIC_SERVERS[response_string]
-    ensure
-      VCR.http_stubbing_adapter.ignore_localhost = orig_ignore_localhost
-    end
-  end
-
-  def recorded_interactions_for(cassette_name)
-    interactions = YAML.load(File.read(file_name(cassette_name)))
-  end
-
-  def file_name(cassette_name)
-    File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-  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
-
-end
-World(VCRHelpers)
-
-Given /^we do not have a "([^\"]*)" cassette$/ do |cassette_name|
-  File.exist?(file_name(cassette_name)).should be_false
-end
-
-Given /^we have a "([^\"]*)" library file with (a|no) previously recorded response for "([^\"]*)"$/ do |cassette_name, a_or_no, url|
-  fixture_file = file_name(cassette_name)
-  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 /^the "([^\"]*)" library file has a response for \/(\S+)\/ that matches \/(.+)\/$/ do |cassette_name, url_regex, body_regex|
-  recorded_interactions_for(cassette_name).should have_expected_response(body_regex, :url => /#{url_regex}/)
-end
-
-Given /^the "([^"]*)" library file has a response for "([^"]*)" with the request body "([^"]*)" that matches \/(.+)\/$/ do |cassette_name, url, request_body, response_regex|
-  recorded_interactions_for(cassette_name).should have_expected_response(response_regex, :url => url, :request_body => request_body)
-end
-
-Given /^the "([^"]*)" library file has a response for "([^"]*)" with the request header "([^"]*)=([^"]*)" that matches \/(.+)\/$/ do |cassette_name, url, header_key, header_value, response_regex|
-  recorded_interactions_for(cassette_name).should have_expected_response(response_regex, :url => url, :request_headers => { header_key => header_value })
-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|
-    make_http_request(:get, url)
-  end
-end
-
-When /^I make an HTTP post request to "([^"]*)" with request body "([^"]*)"$/ do |url, request_body|
-  capture_response(url) do |uri, path|
-    make_http_request(:post, url, request_body)
-  end
-end
-
-When /^I make an HTTP post request to "([^"]*)" with request header "([^"]*)=([^"]*)"$/ do |url, header_key, header_val|
-  capture_response(url) do |uri, path|
-    make_http_request(:post, url, '', { header_key => header_val })
-  end
-end
-
-When /^I make (.*) requests? to "([^\"]*)"(?: and "([^\"]*)")? while using the "([^\"]*)" cassette(?: using cassette options: (.*))?$/ do |http_request_type, url1, url2, cassette_name, options|
-  options = options.to_s == '' ? { :record => :new_episodes } : eval(options)
-  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
-
-When /^I make an HTTP post request to "([^"]*)" with request body "([^"]*)" while using the "([^"]*)" cassette(?: using cassette options: (.*))?$/ do |url, request_body, cassette_name, options|
-  options = options.to_s == '' ? { :record => :new_episodes } : eval(options)
-  VCR.use_cassette(cassette_name, options) do
-    When %{I make an HTTP post request to "#{url}" with request body "#{request_body}"}
-  end
-end
-
-When /^I make an HTTP post request to "([^"]*)" with request header "([^"]*)=([^"]*)" while using the "([^"]*)" cassette(?: using cassette options: (.*))?$/ do |url, header_key, header_value, cassette_name, options|
-  options = options.to_s == '' ? { :record => :new_episodes } : eval(options)
-  VCR.use_cassette(cassette_name, options) do
-    When %{I make an HTTP post request to "#{url}" with request header "#{header_key}=#{header_value}"}
-  end
-end
-
-Then /^the "([^\"]*)" library file (should(?: not)?) have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, expectation, url, regex_str|
-  expectation = expectation.gsub(' ', '_')
-  interactions = recorded_interactions_for(cassette_name)
-  interactions.send(expectation, have_expected_response(regex_str, :url => url))
-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 /^the "([^"]*)" library file should have normalized headers for all recorded interactions$/ do |cassette_name|
-  interactions = recorded_interactions_for(cassette_name)
-  interactions.each do |i|
-    i.request.should have_normalized_headers
-    i.response.should have_normalized_headers
-  end
-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
-  response = @http_requests[url][response_num]
-  raise response if response.is_a?(Exception)
-  get_body_string(response).should =~ regex
-end
-
-Then /^there should not be a "([^\"]*)" library file$/ do |cassette_name|
-  File.exist?(file_name(cassette_name)).should be_false
-end
-
-Given /^the ignore_localhost config setting is set to (true|false)$/ do |value|
-  VCR::Config.ignore_localhost = eval(value)
-end
-
-Given /^a rack app is running on localhost that returns "([^"]+)" for all requests$/ do |response_string|
-  @rack_server = static_rack_server(response_string)
-end
-
-When /^I make an HTTP get request to the localhost rack app while using the "([^\"]*)" cassette$/ do |cassette|
-  When %{I make an HTTP get request to "http://localhost:#{@rack_server.port}/" while using the "#{cassette}" cassette}
-end
-
-Then /^the response for the localhost rack app should match \/(.*)\/$/ do |regex|
-  Then %{the response for "http://localhost:#{@rack_server.port}/" should match /#{regex}/}
-end
-
-Given /^the "([^\"]*)" library file has a response for localhost that matches \/(.*)\/$/ do |cassette, regex|
-  port = static_rack_server('localhost response').port
-  Given %{the "#{cassette}" library file has a response for "http://localhost:#{port}/" that matches /#{regex}/}
-end
-
-Given /^(\d+) days have passed since the "([^"]*)" library file last changed$/ do |day_count, file|
-  last_changed_at = File.new(file_name(file)).mtime
-  Timecop.travel(last_changed_at + day_count.to_i.days)
-end
-
-Given /the following files do not exist:/ do |files|
-  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
-end