vcr 0.3.1 → 0.4.0

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Myron Marston
@@ -14,11 +14,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-10 00:00:00 -07:00
+date: 2010-04-28 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: fakeweb
+  name: rspec
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
@@ -27,39 +27,53 @@ dependencies:
         segments: 
         - 1
         - 2
-        - 8
-        version: 1.2.8
-  type: :runtime
+        - 9
+        version: 1.2.9
+  type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: cucumber
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
+        - 0
+        - 6
         - 1
-        - 2
-        - 9
-        version: 1.2.9
+        version: 0.6.1
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: cucumber
+  name: fakeweb
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 0
-        - 6
         - 1
-        version: 0.6.1
+        - 2
+        - 8
+        version: 1.2.8
   type: :development
   version_requirements: *id003
-description: 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.
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :development
+  version_requirements: *id004
+description: VCR provides helpers to record your test suite's HTTP interactions and replay them during future test runs for fast, deterministic, accurate tests.  It works with any ruby testing framework, and provides built-in support for cucumber.
 email: myron.marston@gmail.com
 executables: []
 
@@ -67,15 +81,16 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README.rdoc
+- README.md
 files: 
 - .document
 - .gitignore
-- History.rdoc
+- CHANGELOG.md
 - LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
+- benchmarks/http_stubbing_libraries.rb
 - features/fixtures/vcr_cassettes/1.8.6/cucumber_tags/replay_cassette1.yml
 - features/fixtures/vcr_cassettes/1.8.6/cucumber_tags/replay_cassette2.yml
 - features/fixtures/vcr_cassettes/1.8.6/cucumber_tags/replay_cassette3.yml
@@ -103,23 +118,46 @@ files:
 - lib/vcr/extensions/fake_web.rb
 - lib/vcr/extensions/net_http.rb
 - lib/vcr/extensions/net_read_adapter.rb
-- lib/vcr/recorded_response.rb
+- lib/vcr/http_stubbing_adapters/base.rb
+- lib/vcr/http_stubbing_adapters/fakeweb.rb
+- lib/vcr/http_stubbing_adapters/webmock.rb
+- lib/vcr/structs.rb
+- lib/vcr/task_runner.rb
+- lib/vcr/tasks/vcr.rake
 - spec/cassette_spec.rb
 - spec/config_spec.rb
 - spec/cucumber_tags_spec.rb
 - spec/deprecations_spec.rb
-- spec/extensions/fake_web_spec.rb
 - spec/extensions/net_http_spec.rb
 - spec/extensions/net_read_adapter_spec.rb
+- spec/fixtures/1.8.6/0_3_1_cassette.yml
 - spec/fixtures/1.8.6/cassette_spec/example.yml
+- spec/fixtures/1.8.6/example_net_http.yml
+- spec/fixtures/1.8.6/example_net_http_request.yml
+- spec/fixtures/1.8.6/example_net_http_response.yml
+- spec/fixtures/1.8.6/fake_example.com_responses.yml
+- spec/fixtures/1.8.7/0_3_1_cassette.yml
 - spec/fixtures/1.8.7/cassette_spec/example.yml
+- spec/fixtures/1.8.7/example_net_http.yml
+- spec/fixtures/1.8.7/example_net_http_request.yml
+- spec/fixtures/1.8.7/example_net_http_response.yml
+- spec/fixtures/1.8.7/fake_example.com_responses.yml
+- spec/fixtures/1.9.1/0_3_1_cassette.yml
 - spec/fixtures/1.9.1/cassette_spec/example.yml
-- spec/recorded_response_spec.rb
+- spec/fixtures/1.9.1/example_net_http.yml
+- spec/fixtures/1.9.1/example_net_http_request.yml
+- spec/fixtures/1.9.1/example_net_http_response.yml
+- spec/fixtures/1.9.1/fake_example.com_responses.yml
+- spec/http_stubbing_adapters/fakeweb_spec.rb
+- spec/http_stubbing_adapters/webmock_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/structs_spec.rb
 - spec/support/deprecated.rb
 - spec/support/disable_warnings.rb
+- spec/support/http_stubbing_adapter.rb
 - spec/support/temp_cassette_library_dir.rb
+- spec/task_runner_spec.rb
 - spec/vcr_spec.rb
 - vcr.gemspec
 has_rdoc: true
@@ -151,18 +189,21 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Use VCR to record HTTP responses and replay them using fakeweb.
+summary: Record your test suite's HTTP interactions and replay them during future test runs for fast, deterministic, accurate tests.
 test_files: 
 - spec/cassette_spec.rb
 - spec/config_spec.rb
 - spec/cucumber_tags_spec.rb
 - spec/deprecations_spec.rb
-- spec/extensions/fake_web_spec.rb
 - spec/extensions/net_http_spec.rb
 - spec/extensions/net_read_adapter_spec.rb
-- spec/recorded_response_spec.rb
+- spec/http_stubbing_adapters/fakeweb_spec.rb
+- spec/http_stubbing_adapters/webmock_spec.rb
 - spec/spec_helper.rb
+- spec/structs_spec.rb
 - spec/support/deprecated.rb
 - spec/support/disable_warnings.rb
+- spec/support/http_stubbing_adapter.rb
 - spec/support/temp_cassette_library_dir.rb
+- spec/task_runner_spec.rb
 - spec/vcr_spec.rb

data/History.rdoc

@@ -1,31 +0,0 @@
-== 0.3.1 April 10, 2010
-* Fixed a bug: when Net::HTTP#request was called with a block that had a return statement, the response was not being recorded.
-
-== 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].
-* Deprecated the default_cassette_record_mode option.  Use default_cassette_options instead.
-
-== 0.1.2 March 4, 2010
-* Added explanatory note about VCR to FakeWeb::NetConnectNotAllowedError#message.
-* Got things to work for when a cassette records multiple requests made to the same URL with the same HTTP verb,
-  but different responses. We have to register an array of responses with fakeweb.
-* Fixed our Net::HTTP monkey patch so that it only stores a the recorded response once per request.
-  Internally, Net::HTTP#request recursively calls itself (passing slightly different arguments) in certain circumstances.
-
-== 0.1.1 February 25, 2010
-* Handle asynchronous HTTP requests (such as for mechanize).  Bug reported by {Thibaud Guillaume-Gentil}[http://github.com/thibaudgg].
-
-== 0.1.0 February 25, 2010
-* Initial release.  Basic recording and replaying of responses works.

data/README.rdoc

@@ -1,222 +0,0 @@
-= VCR
-
-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.
-
-== Installation
-
-  gem install vcr
-
-== Background
-
-This README assumes you are familiar with FakeWeb; if not, please checkout the {README}[http://github.com/chrisk/fakeweb/blob/master/README.rdoc].
-
-VCR was inspired by {NetRecorder}[http://github.com/chrisyoung/netrecorder], but was designed from the ground up to support
-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 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 insert a cassette, it does
-the following:
-
-* 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 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 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 inserted.
-
-== Record modes
-
-VCR supports 3 record modes, which configure when it records new responses.  You can set a default
-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 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.
-
-== Configuration
-
-  require 'vcr'
-
-  # Set the default allow_net_connect option--usually you'll want this off.
-  # You don't usually want your test suite to make HTTP connections, do you?
-  FakeWeb.allow_net_connect = false
-
-  VCR.config do |c|
-    # 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 = {
-      :record          => :none,
-      :allow_real_http => :localhost
-    }
-  end
-
-This can go pretty much wherever, as long as this code is run before your tests, specs or scenarios.  I tend
-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.use_cassette</tt>:
-
-  VCR.use_cassette('geocoding/Seattle, WA', :record => :new_episodes) do
-    # do something that causes an HTTP request.
-  end
-
-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.insert_cassette('geocoding/Seattle, WA', :record => :new_episodes)
-    end
-
-    it "should do something that makes an HTTP request"
-
-    after(:each) do
-      VCR.eject_cassette
-    end
-  end
-
-In both of these cases, VCR would use the file geocoding/Seattle_WA.yml within the configured
-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.use_cassette('my cassette', :allow_real_http => lambda { |uri| uri.host == 'google.com' }) do
-    # do something that causes an HTTP request.
-  end
-
-In this case, any google HTTP requests will be made for real, regardless of your <tt>FakeWeb.allow_net_connect</tt> setting,
-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.use_cassette('my cassette', :allow_real_http => :localhost) do
-    # do something that causes an HTTP request.
-  end
-
-This is equivalent to using a lambda like:
-
-  lambda { |uri| uri.host == 'localhost' }
-
-This is needed for using VCR with {capybara}[http://github.com/jnicklas/capybara] and any of the javascript drivers (see below for more info).
-
-== Usage with Cucumber
-
-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.
-
-First, tag your scenario with something descriptive:
-
-  @facebook_http_request
-  Scenario: Sign up with facebook connect
-
-Then let VCR know about this tag, in features/support/vcr.rb (or some similar support file):
-
-  VCR.cucumber_tags do |t|
-    t.tags '@facebook_http_request', '@twitter_status_update', :record => :none
-    t.tags '@another_scenario_tag'   # the default record mode will be used for this tag.
-  end
-
-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 cassette library dir.
-
-== Usage with Capybara
-
-When you use any of the javascript-enabled drivers (selenium, celerity, culerity) with {capybara}[http://github.com/jnicklas/capybara],
-it'll need to ping the app running on localhost.  You can use the <tt>:allow_real_http => :localhost</tt> option to allow this.
-
-== 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 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:
-
-  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.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.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>: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.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
-
-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 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 its library file.
-* You can use a directory separator (i.e. '/') in your cassette names to cause it to use a subdirectory
-  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.
-
-== Note on Patches/Pull Requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
-
-== Thanks
-
-* {Aslak Hellesøy}[http://github.com/aslakhellesoy] for {Cucumber}[http://github.com/aslakhellesoy/cucumber].
-* {Chris Kampmeier}[http://github.com/chrisk] for {FakeWeb}[http://github.com/chrisk/fakeweb].
-* {Chris Young}[http://github.com/chrisyoung] for {NetRecorder}[http://github.com/chrisyoung/netrecorder], the inspiration
-  for VCR.
-
-== Copyright
-
-Copyright (c) 2010 Myron Marston. See LICENSE for details.

data/lib/vcr/recorded_response.rb

@@ -1,4 +0,0 @@
-module VCR
-  class RecordedResponse < Struct.new(:method, :uri, :response)
-  end
-end

data/spec/extensions/fake_web_spec.rb

@@ -1,63 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe "FakeWeb Extensions" do
-  describe "#remove_from_registry with (:get, 'http://example.com')" do
-    before(:each) do
-      FakeWeb.register_uri(:get, 'http://example.com', :body => "Example dot com!")
-      FakeWeb.register_uri(:post, 'http://example.com', :body => "Example dot com!")
-      FakeWeb.register_uri(:get, 'http://google.com', :body => "Google dot com!")
-      @remove_example_dot_com = lambda { FakeWeb.remove_from_registry(:get, 'http://example.com') }
-    end
-
-    it "removes the :get http://example.com registration" do
-      @remove_example_dot_com.should change { FakeWeb.registered_uri?(:get, 'http://example.com') }.from(true).to(false)
-    end
-
-    it "does not remove the :post http://example.com registration" do
-      FakeWeb.registered_uri?(:post, 'http://example.com').should be_true
-      @remove_example_dot_com.should_not change { FakeWeb.registered_uri?(:post, 'http://example.com') }
-    end
-
-    it "does not affect other registered uris" do
-      FakeWeb.registered_uri?(:get, 'http://google.com').should be_true
-      @remove_example_dot_com.should_not change { FakeWeb.registered_uri?(:get, 'http://google.com') }
-    end
-  end
-
-  describe 'FakeWeb::NetConnectNotAllowedError#message' do
-    it 'includes a note about VCR' do
-      FakeWeb::NetConnectNotAllowedError.new('The fakeweb error message').message.should ==
-      'The fakeweb error message.  You can use VCR to automatically record this request and replay it later with fakeweb.  For more details, see the VCR README at: http://github.com/myronmarston/vcr'
-    end
-  end
-
-  describe "#with_allow_net_connect_set_to" do
-    it 'sets allow_net_connect for the duration of the block to the provided value' do
-      [true, false].each do |expected|
-        yielded_value = :not_set
-        FakeWeb.with_allow_net_connect_set_to(expected) { yielded_value = FakeWeb.allow_net_connect? }
-        yielded_value.should == expected
-      end
-    end
-
-    it 'returns the value returned by the block' do
-      FakeWeb.with_allow_net_connect_set_to(true) { :return_value }.should == :return_value
-    end
-
-    it 'reverts allow_net_connect when the block completes' do
-      [true, false].each do |expected|
-        FakeWeb.allow_net_connect = expected
-        FakeWeb.with_allow_net_connect_set_to(true) { }
-        FakeWeb.allow_net_connect?.should == expected
-      end
-    end
-
-    it 'reverts allow_net_connect when the block completes, even if an error is raised' do
-      [true, false].each do |expected|
-        FakeWeb.allow_net_connect = expected
-        lambda { FakeWeb.with_allow_net_connect_set_to(true) { raise RuntimeError } }.should raise_error(RuntimeError)
-        FakeWeb.allow_net_connect?.should == expected
-      end
-    end
-  end
-end