vcr 0.2.0 → 0.3.0

data/History.rdoc

@@ -1,3 +1,14 @@
+== 0.3.0 March 24, 2010
+* Renamed a bunch of methods, replacing them with method names that more clearly fit the VCR/cassette metaphor:
+  * VCR.create_cassette! => VCR.insert_cassette
+  * VCR.destroy_cassette! => VCR.eject_cassette
+  * VCR.with_cassette => VCR.use_cassette
+  * VCR::Cassette#destroy! => VCR::Cassette#eject
+  * VCR::Cassette#cache_file => VCR::Cassette#file
+  * VCR::Config.cache_dir => VCR::Config.cassette_library_dir
+  * :unregistered record mode => :new_episodes record mode
+* All the old methods still work, but you'll get deprecation warnings.
+
 == 0.2.0 March 9, 2010
 * Added <tt>:allow_real_http</tt> cassette option, which allows VCR to work with capybara and a javascript driver.
   Bug reported by {Ben Hutton}[http://github.com/benhutton].

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Myron Marston
+Copyright (c) 2010 Myron Marston
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -15,26 +15,26 @@ VCR was inspired by {NetRecorder}[http://github.com/chrisyoung/netrecorder], but
 localized recording and replaying, rather than the global recording and replaying of NetRecorder.  In general, I believe that
 tests should not rely upon anything global.  You're coupling your test to something outside of it that may later change and
 break the test.  It's far better to localize things to each test, as much as possible.  VCR, in combination with FakeWeb,
-makes it easy to do this with the recording and replying of HTTP responses.
+makes it easy to do this with the recording and replaying of HTTP responses.
 
 == Cassettes
 
 Cassettes are central to the way VCR works.  They are a similar to VHS cassettes--your library of cassettes
-is your library of previously recorded responses that can be replayed.  When you create a cassette, it does
+is your library of previously recorded responses that can be replayed.  When you insert a cassette, it does
 the following:
 
-* It loads the previously recorded responses from the cache file corresponding to the cassette name.
+* It loads the previously recorded responses from the library file corresponding to the cassette name.
 * It register these responses with fakeweb (depending on the cassette's :record option--see below)
 * It sets the <tt>FakeWeb.allow_net_connect</tt> setting based on the cassette's :record option.
 
 While a cassette is active, any HTTP requests to a URL of a previously recorded response will use
 the recorded response.  New HTTP requests (i.e. HTTP requests that have not been previously recorded)
-will be recorded to the same cache file, depending on your :record option.  When you destroy a cassette,
+will be recorded to the same library file, depending on your :record option.  When you eject a cassette,
 it does the following:
 
-* It saves all of the recorded responses (both old and new) to a cached yml file corresponding to the cassette name.
+* It saves all of the recorded responses (both old and new) to a yml library file corresponding to the cassette name.
 * It removes the registrations it made with fakeweb, to prevent "leakage" into other tests.
-* It reverts the <tt>FakeWeb.allow_net_connect</tt> back to whatever it was before the cassette was created.
+* It reverts the <tt>FakeWeb.allow_net_connect</tt> back to whatever it was before the cassette was inserted.
 
 == Record modes
 
@@ -42,20 +42,20 @@ VCR supports 3 record modes, which configure when it records new responses.  You
 record mode in your configuration (see below) and a per-cassette record mode when creating a cassette.  The record
 modes are:
 
+* <tt>:new_episodes</tt> - This will use the previously recorded responses, and record any new requests that are not registered with
+  fakeweb.  The previously recorded responses will be registered with fakeweb.  <tt>FakeWeb.allow_net_connect</tt> will be
+  set to true, so that VCR will record any new HTTP requests within the cassette.  Use this when it's ok for external HTTP
+  requests to be made without you explicitly allowing it.  New requests will get saved to the cassette's yml library file, and
+  automatically get used in the future.
 * <tt>:all</tt> - This will cause VCR to re-record all HTTP requests that occur.
   When the cassette is created, it will not register any of the cached responses with fakeweb.
   <tt>FakeWeb.allow_net_connect</tt> will be set to true, so it can record the requests.  Use this
   when you want to re-record all of the HTTP requests for a cassette.  Alternately, you can simply
-  delete the corresponding cache file and use the :unregistered record mode, described below.
+  delete the corresponding library file and use the :new_episodes record mode, described above.
 * <tt>:none</tt> - This will prevent VCR from recording, or even allowing, any new HTTP requests.
   The previously recorded responses will be registered with fakeweb.  <tt>FakeWeb.allow_net_connect</tt> will be set to
   false, so that no new HTTP connections are allowed.  Use this when you want to guarantee that no external
   HTTP requests will be made while the given cassette is active.  Fakeweb will raise an error in this case.
-* <tt>:unregistered</tt> - This will use the previously recorded responses, and record any new requests that are not registered with
-  fakeweb.  The previously recorded responses will be registered with fakeweb.  <tt>FakeWeb.allow_net_connect</tt> will be
-  set to true, so that VCR will record any new HTTP requests within the cassette.  Use this when it's ok for external HTTP
-  requests to be made without you explicitly allowing it.  New requests will get saved to the cassettes yml file, and
-  automatically get used in the future.
 
 == Configuration
 
@@ -66,8 +66,8 @@ modes are:
   FakeWeb.allow_net_connect = false
 
   VCR.config do |c|
-    # the cache_dir is where the cassette yml files will be saved.
-    c.cache_dir = File.join(Rails.root, 'features', 'fixtures', 'vcr_cassettes')
+    # the cassette_library_dir is where the cassette yml files will be saved.
+    c.cassette_library_dir = File.join(Rails.root, 'features', 'fixtures', 'cassette_library')
 
     # these options will be used as defaults for your cassettes, but you can override them in each individual cassette.
     c.default_cassette_options = {
@@ -81,33 +81,33 @@ to put it in spec/support/vcr.rb, test/support/vcr.rb or features/support/vcr.rb
 
 == Usage with your favorite test/spec framework
 
-VCR can easily be used with any ruby test or spec framework.  Usually, you'll want to use <tt>VCR.with_cassette</tt>:
+VCR can easily be used with any ruby test or spec framework.  Usually, you'll want to use <tt>VCR.use_cassette</tt>:
 
-  VCR.with_cassette('geocoding/Seattle, WA', :record => :unregistered) do
+  VCR.use_cassette('geocoding/Seattle, WA', :record => :new_episodes) do
     # do something that causes an HTTP request.
   end
 
-Alternately, you can create and destroy the cassette with individual method calls from setup/before and teardown/after:
+Alternately, you can insert and eject the cassette with individual method calls from setup/before and teardown/after:
 
   describe "Something that makes an HTTP request" do
     before(:each) do
-      VCR.create_cassette!('geocoding/Seattle, WA', :record => :unregistered)
+      VCR.insert_cassette('geocoding/Seattle, WA', :record => :new_episodes)
     end
 
     it "should do something that makes an HTTP request"
 
     after(:each) do
-      VCR.destroy_cassette!
+      VCR.eject_cassette
     end
   end
 
 In both of these cases, VCR would use the file geocoding/Seattle_WA.yml within the configured
-cache dir.  The :record setting is optional--if you leave it blank, your configured default will be used.
+cassette library dir.  The :record setting is optional--if you leave it blank, your configured default will be used.
 
 Besides the :record option, cassettes also support the :allow_real_http option.  You can use this to make the cassette
 allow some real HTTP requests.  You can specify it with a lambda:
 
-  VCR.with_cassette('my cassette', :allow_real_http => lambda { |uri| uri.host == 'google.com' }) do
+  VCR.use_cassette('my cassette', :allow_real_http => lambda { |uri| uri.host == 'google.com' }) do
     # do something that causes an HTTP request.
   end
 
@@ -115,7 +115,7 @@ In this case, any google HTTP requests will be made for real, regardless of your
 your current record mode, and whether or not you are recording or replaying this cassette.  Non-google requests will do
 the appropriate recording/replaying as usual.  You can also use the special <tt>:localhost</tt> option:
 
-  VCR.with_cassette('my cassette', :allow_real_http => :localhost) do
+  VCR.use_cassette('my cassette', :allow_real_http => :localhost) do
     # do something that causes an HTTP request.
   end
 
@@ -127,7 +127,7 @@ This is needed for using VCR with {capybara}[http://github.com/jnicklas/capybara
 
 == Usage with Cucumber
 
-VCR provides special support for cucumber.  You can of course use <tt>VCR.with_cassette</tt> within a step definition,
+VCR provides special support for cucumber.  You can of course use <tt>VCR.use_cassette</tt> within a step definition,
 and that's the recommended way for any of your step definitions.  But many times I find myself using generic step definitions
 provided by another library (such as the webrat/capybara web steps generated by cucumber-rails), and I don't want to modify
 these.  VCR provides cucumber tagging support to help in these cases.
@@ -147,7 +147,7 @@ Then let VCR know about this tag, in features/support/vcr.rb (or some similar su
 For each of the tags you specify in your cucumber_tags block, VCR will set up the appropriate
 {Before and After hooks}[http://wiki.github.com/aslakhellesoy/cucumber/hooks] to use a cassette
 for the entire scenario.  The tag (minus the '@') will be used as the cassette name, and it'll
-go in the cucumber_tags subdirectory of the configured cache dir.
+go in the cucumber_tags subdirectory of the configured cassette library dir.
 
 == Usage with Capybara
 
@@ -157,8 +157,7 @@ it'll need to ping the app running on localhost.  You can use the <tt>:allow_rea
 == Suggested Workflow
 
 First, configure VCR and FakeWeb as I have above.  I like setting <tt>FakeWeb.allow_net_connect</tt> to <tt>false</tt>
-and VCR's <tt>default_cassette_record_mode</tt> to <tt>:none</tt> so that no new HTTP requests are made without me
-explicitly allowing it.
+and the default record mode to <tt>:none</tt> so that no new HTTP requests are made without me explicitly allowing it.
 
 When an HTTP request is made, you'll get an {error from FakeWeb}[http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L62-63],
 such as:
@@ -166,37 +165,37 @@ such as:
   FakeWeb::NetConnectNotAllowedError: Real HTTP connections are disabled. Unregistered request: get http://example.com
 
 Find the place that is making the HTTP request (the backtrace should help here).  If you've already recorded this HTTP
-request to a cassette from a different test, you can simply re-use the cassette.  Use <tt>VCR.with_cassette</tt>, as
+request to a cassette from a different test, you can simply re-use the cassette.  Use <tt>VCR.use_cassette</tt>, as
 shown above.  You may also want to refactor this into a helper method that sets up the VCR cassette and does whatever
 makes the HTTP request:
 
   def set_user_address(user, address, city, state)
-    VCR.with_cassette("geocoding/#{address}, #{city}, #{state}", :record => :unregistered) do
+    VCR.use_cassette("geocoding/#{address}, #{city}, #{state}", :record => :new_episodes) do
       user.address.update_attributes!(:address => address, :city => city, :state => state)
     end
   end
 
 In this case, I've used a dynamic cassette name based on the address being geocoded.  That way, each separate address
 gets a different cassette, and tests that set the same user address will reuse the same cassette.  I've also set
-the record mode to <tt>:unregistered</tt> so that VCR will automatically record geocoding requests for a new address
+the record mode to <tt>:new_episodes</tt> so that VCR will automatically record geocoding requests for a new address
 to a new cassette, without me having to do anything.
 
-If the HTTP request that triggered the error is new, you'll have to record it for the first time.  Simply use <tt>VCR.with_cassette</tt>
-with the record mode set to <tt>:unregistered</tt> or <tt>:all</tt>.  Run the test again, and VCR will record the HTTP response.  I usually
+If the HTTP request that triggered the error is new, you'll have to record it for the first time.  Simply use <tt>VCR.use_cassette</tt>
+with the record mode set to <tt>:new_episodes</tt> or <tt>:all</tt>.  Run the test again, and VCR will record the HTTP response.  I usually
 remove the record mode at this point so that it uses the default of <tt>:none</tt> in the future.  Future test runs will use the
 recorded response, and if your code changes so that it is making a new HTTP request, you'll get the same FakeWeb error as shown above.
 
 == Ruby Version Compatibility
 
-  specs.should pass if RUBY_VERSION =~ /^1.(8.6|8.7|9.1)$/
+VCR works on ruby {1.8.6}[http://integrity186.heroku.com/vcr], {1.8.7}[http://integrity187.heroku.com/vcr] and {1.9.1}[http://integrity191.heroku.com/vcr].
 
 == Notes, etc.
 
-* The cassette name determines the name of the cache file for the given cassette.  Strings or symbols are fine,
+* The cassette name determines the name of the library file for the given cassette.  Strings or symbols are fine,
   and you can include any characters, but spaces and invalid file name characters will be removed
-  before the cassette reads or writes to the file.
+  before the cassette reads or writes to its library file.
 * You can use a directory separator (i.e. '/') in your cassette names to cause it to use a subdirectory
-  of the cache_dir.  The cucumber tagging support uses this.
+  of the cassette_library_dir.  The cucumber tagging support uses this.
 * VCR maintains a simple stack of cassettes.  This allows you to nest them as deeply as you want.
   This is particularly useful when you have a cucumber step definition that uses a cassette, and
   you also want to use a cassette for the entire scenario using the tagging support.

data/Rakefile

@@ -6,7 +6,7 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "vcr"
     gem.summary = %Q{Use VCR to record HTTP responses and replay them using fakeweb.}
-    gem.description = %Q{VCR provides helpers to record HTTP requests for URIs that are not registered with fakeweb, and replay them later.  It provides built-in support for cucumber, but works with any ruby testing framework.}
+    gem.description = %Q{VCR provides helpers to record HTTP requests for URIs that are not registered with fakeweb, and replay them later.  It works with any ruby testing framework, and provides built-in support for cucumber.}
     gem.email = "myron.marston@gmail.com"
     gem.homepage = "http://github.com/myronmarston/vcr"
     gem.authors = ["Myron Marston"]

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/features/record_response.feature

@@ -3,21 +3,21 @@ Feature: Record response
   As a TDD/BDD developer
   I want to record responses for requests to URIs that are not registered with fakeweb so I can use them with fakeweb in the future
 
-  Scenario: Record a response using VCR.with_cassette
+  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" cache file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
+     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 destroyed
+     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" cache file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
+     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
@@ -27,46 +27,46 @@ Feature: Record 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 "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 destroyed
-      And the "temp/nested" cache file should have a response for "http://example.com/nested" that matches /The requested URL \/nested was not found/
+     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" cache 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" cache file should have a response for "http://example.com/after_nested" that matches /The requested URL \/after_nested was not found/
+     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" cache file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
+     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 a fakeweb error that mentions VCR
-      And there should not be a "temp/record_none_cassette" cache file
+      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 :unregistered
-    Given we have a "temp/not_the_real_response" file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" 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" unregistered cassette
-     Then the "temp/not_the_real_response" cache 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" cache file should have a response for "http://example.com/foo" that matches /The requested URL \/foo was not found/
+  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" unregistered cassette
-     Then the "temp/asynchronous" cache file should have a response for "http://example.com" that matches /You have reached this web page by typing.*example\.com/
+     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" unregistered cassette
-     Then the "temp/recursive_post" cache 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" cache file should have exactly 1 response
+     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" cache file
+      And there should not be a "temp/record_none_cassette" library file

data/features/replay_recorded_response.feature

@@ -3,24 +3,24 @@ Feature: Replay recorded response
   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.with_cassette block
-    Given the "not_the_real_response" cache file has a response for "http://example.com" that matches /This is not the real response from example\.com/
+  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" cache file has a response for "http://example.com" that matches /This is not the real response from example\.com/
+      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" cache file has a response for "http://example.com/before_nested" that matches /The before_nested response/
-      And the "nested_replay_cassette" cache file has a response for "http://example.com/nested" that matches /The nested response/
-      And the "cucumber_tags/replay_cassette2" cache file has a response for "http://example.com/after_nested" that matches /The after_nested response/
+      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"
@@ -30,34 +30,40 @@ Feature: Replay recorded 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" file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" file with no previously recorded response for "http://example.com/foo"
+    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" file with a previously recorded response for "http://example.com"
-      And we have a "temp/not_the_real_response" file with no previously recorded response for "http://example.com/foo"
+    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 a fakeweb error that mentions VCR
 
   @copy_not_the_real_response_to_temp
-  Scenario: Make an HTTP request in a cassette with record mode set to :unregistered
-  Given we have a "temp/not_the_real_response" file with a previously recorded response for "http://example.com"
-    And we have a "temp/not_the_real_response" 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" unregistered cassette
+  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" cache 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" cache file has a response for "http://example.com" that matches /This is another fake response from example\.com/
+      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

@@ -10,29 +10,41 @@ module VCRHelpers
   end
 
   def recorded_responses_for(cassette_name)
-    yaml_file = File.join(VCR::Config.cache_dir, "#{cassette_name}.yml")
+    yaml_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
     yaml = File.open(yaml_file, 'r') { |f| f.read }
     responses = 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
 end
 World(VCRHelpers)
 
 Given /^we do not have a "([^\"]*)" cassette$/ do |cassette_name|
-  fixture_file = File.join(VCR::Config.cache_dir, "#{cassette_name}.yml")
+  fixture_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
   File.exist?(fixture_file).should be_false
 end
 
-Given /^we have a "([^\"]*)" file with (a|no) previously recorded response for "([^\"]*)"$/ do |file_name, a_or_no, url|
-  fixture_file = File.join(VCR::Config.cache_dir, "#{file_name}.yml")
+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 "([^\"]*)" cache file has a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
-  Given %{we have a "#{cassette_name}" file with a previously recorded response for "#{url}"}
-  Then %{the "#{cassette_name}" cache file should have a response for "#{url}" that matches /#{regex_str}/}
+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|
@@ -47,48 +59,57 @@ Given /^the previous scenario was tagged with the vcr cassette tag: "([^\"]*)"$/
   VCR::CucumberTags.tags.should include(tag)
 end
 
-When /^I make an(.*)? HTTP (?:get|post) request to "([^\"]*)"$/ do |request_type, url|
-  @http_requests ||= Hash.new([])
-  uri = URI.parse(url)
-  path = uri.path.to_s == '' ? '/' : uri.path
-  begin
-    case request_type
-      when /asynchronous/
-        result = Net::HTTP.new(uri.host, uri.port).request_get(path) { |r| r.read_body { } }
-        result.body.should be_a(Net::ReadAdapter)
-      when /recursive/
-        result = Net::HTTP.new(uri.host, uri.port).post(path, nil)
-      else
-        result = Net::HTTP.get_response(uri)
-    end
-  rescue => e
-    result = e
+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
-  @http_requests[url] += [result]
 end
 
-When /^I make(?: an)?(.*)? HTTP (get|post) requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"]*)" ?(#{VCR::Cassette::VALID_RECORD_MODES.join('|')})? cassette(?:, allowing requests matching \/([^\/]+)\/)?$/ do |request_type, method, url1, url2, cassette_name, record_mode, allowed|
-  options = { :record => (record_mode ? record_mode.to_sym : :unregistered) }
+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.with_cassette(cassette_name, options) do
+  VCR.use_cassette(cassette_name, options) do
     urls.each do |url|
-      When %{I make an#{request_type} HTTP #{method} request to "#{url}"}
+      When %{I make #{http_request_type} request to "#{url}"}
     end
   end
 end
 
-Then /^the "([^\"]*)" cache file should have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
+Then /^the "([^\"]*)" library file should have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
   responses = recorded_responses_for(cassette_name)
   responses.should have_expected_response(url, regex_str)
 end
 
-Then /^the "([^\"]*)" cache file should have exactly (\d+) response$/ do |cassette_name, response_count|
+Then /^the "([^\"]*)" library file should have exactly (\d+) response$/ do |cassette_name, response_count|
   responses = recorded_responses_for(cassette_name)
   responses.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 destroyed$/ do
+Then /^I can test the scenario cassette's recorded responses in the next scenario, after the cassette has been ejected$/ do
   # do nothing...
 end
 
@@ -105,7 +126,7 @@ Then /^(?:the )?response(?: (\d+))? for "([^\"]*)" should match \/(.+)\/$/ do |r
   @http_requests[url][response_num].body.should =~ regex
 end
 
-Then /^there should not be a "([^\"]*)" cache file$/ do |cassette_name|
-  yaml_file = File.join(VCR::Config.cache_dir, "#{cassette_name}.yml")
+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