vcr 2.5.0 → 2.6.0

data/Rakefile

@@ -1,8 +1,8 @@
 using_git = File.exist?(File.expand_path('../.git/', __FILE__))
 
 if using_git
-  require 'bundler'
   require 'bundler/setup'
+  require 'bundler/gem_helper'
   Bundler::GemHelper.install_tasks
   require 'appraisal'
 end
@@ -15,7 +15,7 @@ RSpec::Core::RakeTask.new(:spec) do |t|
 
   # we require spec_helper so we don't get an RSpec warning about
   # examples being defined before configuration.
-  t.ruby_opts = "-w -I./spec -r./spec/capture_warnings -rspec_helper"
+  t.ruby_opts = "-I./spec -r./spec/capture_warnings -rspec_helper"
   t.rspec_opts = %w[--format progress] if (ENV['FULL_BUILD'] || !using_git)
 end
 
@@ -37,12 +37,12 @@ end
 
 desc "Checks the spec coverage and fails if it is less than 100%"
 task :check_code_coverage do
-  if RUBY_VERSION < '1.9' || RUBY_ENGINE != 'ruby'
+  if RUBY_VERSION.to_f < 1.9 || RUBY_ENGINE != 'ruby'
     puts "Cannot check code coverage--simplecov is not supported on this platform"
   else
     percent = File.read("./coverage/coverage_percent.txt").to_f
     if percent < 98.0
-      raise "Spec coverage was not high enough: #{percent.round(2)}%"
+      abort "Spec coverage was not high enough: #{percent.round(2)}%"
     else
       puts "Nice job! Spec coverage is still above 98%"
     end
@@ -103,11 +103,7 @@ task :prep_relish_release do
   ENV['NEW_RELISH_RELEASE'] = 'true'
 end
 
-task :require_ruby_18 do
-  raise "This must be run on Ruby 1.8" unless RUBY_VERSION =~ /^1\.8/
-end
-
-task :release => [:require_ruby_18, :prep_relish_release, :relish]
+task :release => [:prep_relish_release, :relish]
 
 # For gem-test: http://gem-testers.org/
 task :test => :spec

data/benchmarks/null_logging.rb

@@ -0,0 +1,62 @@
+$LOAD_PATH.unshift "./lib"
+require 'vcr'
+require 'yaml'
+require 'open-uri'
+require 'benchmark'
+
+VCR.configure do |vcr|
+  vcr.cassette_library_dir = './tmp'
+  vcr.hook_into :webmock
+end
+
+def prepare_cassette
+  interactions = 1.upto(100).map do |i|
+    VCR::HTTPInteraction.new(
+      VCR::Request.new(:get, "http://foo.com/#{i}", "", {}),
+      VCR::Response.new(
+        VCR::ResponseStatus.new(200, "OK"),
+        {}, "Response #{i}", "1.1"
+      ),
+      Time.now
+    ).to_hash
+  end
+
+  hash = { "http_interactions" => interactions, "recorded_with" => "VCR #{VCR.version}" }
+  VCR.cassette_persisters[:file_system]["logging.yml"] = YAML.dump(hash)
+end
+
+prepare_cassette
+
+puts "Ruby #{RUBY_DESCRIPTION}"
+
+3.times do
+  puts Benchmark.measure {
+    100.downto(50) do |i|
+      VCR.use_cassette("logging", :record => :none) do
+        open("http://foo.com/#{i}")
+      end
+    end
+  }
+end
+
+# Before optimizing null logging:
+#
+# Ruby ruby 1.9.3p448 (2013-06-27 revision 41675) [x86_64-darwin12.4.0]
+#   1.510000   0.010000   1.520000 (  1.523553)
+#   1.500000   0.010000   1.510000 (  1.510036)
+#   1.500000   0.010000   1.510000 (  1.507076)
+#
+# After applying the patch from #311 (and forcing `debug_logger` to `nil`:
+#
+# Ruby ruby 1.9.3p448 (2013-06-27 revision 41675) [x86_64-darwin12.4.0]
+#   1.480000   0.020000   1.500000 (  1.500136)
+#   1.390000   0.000000   1.390000 (  1.395503)
+#   1.400000   0.010000   1.410000 (  1.403931)
+#
+# After applying my alternate fix:
+#
+# Ruby ruby 1.9.3p448 (2013-06-27 revision 41675) [x86_64-darwin12.4.0]
+#   1.400000   0.010000   1.410000 (  1.410103)
+#   1.380000   0.010000   1.390000 (  1.388467)
+#   1.360000   0.010000   1.370000 (  1.364418)
+

data/features/.nav

@@ -51,7 +51,6 @@
   - playback_repeats.feature
 - test_frameworks:
   - test_unit.feature
-  - shoulda.feature
   - rspec_metadata.feature
   - rspec_macro.feature
   - cucumber.feature

data/features/about_these_examples.md

@@ -15,5 +15,4 @@ provided by `vcr_cucumber_helpers.rb`:
   library.
 
 If you have ideas to clarify or improve any of these cucumber features,
-please submit an [issue](https://github.com/myronmarston/vcr/issues) or
-pull request.
+please submit an [issue](https://github.com/vcr/vcr/issues) or pull request.

data/features/cassettes/allow_unused_http_interactions.feature

@@ -1,7 +1,8 @@
 Feature: Allow Unused HTTP Interactions
 
   If set to false, this cassette option will cause VCR to raise an error
-  when a cassette is ejected and there are unused HTTP interactions remaining.
+  when a cassette is ejected and there are unused HTTP interactions remaining,
+  unless there is already an exception unwinding the callstack.
 
   It verifies that all requests included in the cassette were made, and allows
   VCR to function a bit like a mock object at the HTTP layer.
@@ -84,3 +85,16 @@ Feature: Allow Unused HTTP Interactions
     When I run `ruby disallowed_with_all_requests.rb`
     Then it should pass
 
+  Scenario: Does not silence other errors raised in `use_cassette` block
+    Given a file named "does_not_silence_other_errors.rb" with:
+      """ruby
+      require 'vcr_config'
+
+      VCR.use_cassette("example", :allow_unused_http_interactions => false) do
+        raise "boom"
+      end
+      """
+    When I run `ruby does_not_silence_other_errors.rb`
+    Then it should fail with "boom"
+     And the output should not contain "There are unused HTTP interactions"
+

data/features/cassettes/decompress.feature

@@ -41,7 +41,9 @@ Feature: Decode compressed response
     When I append to file "decompress.rb":
       """ruby
       VCR.use_cassette(:decompress) do
-        Net::HTTP.get_response('localhost', '/', 7777)
+        Net::HTTP.start('localhost', 7777) do |http|
+          http.get('/', 'accept-encoding' => 'identity')
+        end
       end
       """
     And I run `ruby decompress.rb`
@@ -55,7 +57,9 @@ Feature: Decode compressed response
     When I append to file "decompress.rb":
       """ruby
       VCR.use_cassette(:decompress, :decode_compressed_response => true) do
-        Net::HTTP.get_response('localhost', '/', 7777)
+        Net::HTTP.start('localhost', 7777) do |http|
+          http.get('/', 'accept-encoding' => 'identity')
+        end
       end
       """
     And I run `ruby decompress.rb`

data/features/cassettes/format.feature

@@ -69,8 +69,8 @@ Feature: Cassette format
       end
 
       VCR.use_cassette('example') do
-        make_http_request(:get, "http://localhost:7777/foo")
-        make_http_request(:get, "http://localhost:7777/bar")
+        make_http_request(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
+        make_http_request(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
       end
       """
     When I run `ruby cassette_yaml.rb 'Hello'`
@@ -84,7 +84,9 @@ Feature: Cassette format
           body: 
             encoding: UTF-8
             string: ""
-          headers: {}
+          headers: 
+            Accept-Encoding: 
+            - identity
         response: 
           status: 
             code: 200
@@ -105,7 +107,9 @@ Feature: Cassette format
           body: 
             encoding: UTF-8
             string: ""
-          headers: {}
+          headers: 
+            Accept-Encoding: 
+            - identity
         response: 
           status: 
             code: 200
@@ -153,8 +157,8 @@ Feature: Cassette format
       end
 
       VCR.use_cassette('example', :serialize_with => :json) do
-        puts response_body_for(:get, "http://localhost:7777/foo")
-        puts response_body_for(:get, "http://localhost:7777/bar")
+        puts response_body_for(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
+        puts response_body_for(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
       end
       """
     When I run `ruby cassette_json.rb 'Hello'`
@@ -185,7 +189,9 @@ Feature: Cassette format
                 "string": ""
               },
               "method": "get",
-              "headers": { }
+              "headers": {
+                "Accept-Encoding": [ "identity" ]
+              }
             },
             "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
           },
@@ -212,7 +218,9 @@ Feature: Cassette format
                 "string": ""
               },
               "method": "get",
-              "headers": { }
+              "headers": {
+                "Accept-Encoding": [ "identity" ]
+              }
             },
             "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
           }
@@ -254,8 +262,8 @@ Feature: Cassette format
       end
 
       VCR.use_cassette('example', :serialize_with => :ruby) do
-        puts response_body_for(:get, "http://localhost:7777/foo")
-        puts response_body_for(:get, "http://localhost:7777/bar")
+        puts response_body_for(:get, "http://localhost:7777/foo", nil, 'Accept-Encoding' => 'identity')
+        puts response_body_for(:get, "http://localhost:7777/bar", nil, 'Accept-Encoding' => 'identity')
       end
       """
     When I run `ruby cassette_ruby.rb 'Hello'`
@@ -266,7 +274,7 @@ Feature: Cassette format
            {"method"=>"get",
             "uri"=>"http://localhost:7777/foo",
             "body"=>{"encoding"=>"UTF-8", "string"=>""},
-            "headers"=>{"Accept"=>["*/*"], "User-Agent"=>["Ruby"]}},
+            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
           "response"=>
            {"status"=>{"code"=>200, "message"=>"OK "},
             "headers"=>
@@ -280,7 +288,7 @@ Feature: Cassette format
            {"method"=>"get",
             "uri"=>"http://localhost:7777/bar",
             "body"=>{"encoding"=>"UTF-8", "string"=>""},
-            "headers"=>{"Accept"=>["*/*"], "User-Agent"=>["Ruby"]}},
+            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
           "response"=>
            {"status"=>{"code"=>200, "message"=>"OK "},
             "headers"=>

data/features/cassettes/freezing_time.feature

@@ -0,0 +1,68 @@
+Feature: Freezing Time
+
+  When dealing with an HTTP API that includes time-based compontents
+  in the request (e.g. for signed S3 requests), it can be useful
+  on playback to freeze time to what it originally was when the
+  cassette was recorded so that the request is always the same
+  each time your test is run.
+
+  While VCR doesn't directly support time freezing, it does
+  expose `VCR::Cassette#originally_recorded_at`, which you can
+  easily use with a library like
+  [timecop](https://github.com/travisjeffery/timecop)
+  to freeze time.
+
+  Note: `VCR::Cassette#originally_recorded_at` will return `nil`
+  when the cassette is recording for the first time, so you'll
+  probably want to use an expression like
+  `cassette.originally_recorded_at || Time.now` so that it
+  will work when recording or when playing back.
+
+  Scenario: Previously recorded responses are replayed
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: get
+          uri: http://example.com/events/since/2013-09-23T17:00:30Z
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "20"
+          body: 
+            encoding: UTF-8
+            string: Some Event
+          http_version: "1.1"
+        recorded_at: Mon, 23 Sep 2013 17:00:30 GMT
+      recorded_with: VCR 2.0.0
+      """
+    Given a file named "freeze_time.rb" with:
+      """ruby
+      require 'time'
+      require 'timecop'
+      require 'vcr'
+
+      VCR.configure do |vcr|
+        vcr.cassette_library_dir = 'cassettes'
+        vcr.hook_into :webmock
+      end
+
+      VCR.use_cassette('example') do |cassette|
+        Timecop.freeze(cassette.originally_recorded_at || Time.now) do
+          path = "/events/since/#{Time.now.getutc.iso8601}"
+          response = Net::HTTP.get_response('example.com', path)
+          puts "Response: #{response.body}"
+        end
+      end
+      """
+    When I run `ruby freeze_time.rb`
+    Then it should pass with "Response: Some Event"
+

data/features/configuration/cassette_library_dir.feature

@@ -3,6 +3,11 @@ Feature: cassette_library_dir
   The `cassette_library_dir` configuration option sets a directory
   where VCR saves each cassette.
 
+  Note: When using Rails, avoid using the `test/fixtures` directory 
+  to store the cassettes. Rails treats any YAML file in the fixtures 
+  directory as an ActiveRecord fixture.
+  This will cause an `ActiveRecord::Fixture::FormatError` to be raised.
+
   Scenario: cassette_library_dir
     Given a file named "cassette_library_dir.rb" with:
       """ruby

data/features/configuration/preserve_exact_body_bytes.feature

@@ -81,6 +81,11 @@ Feature: Preserve Exact Body Bytes
         c.cassette_library_dir = 'cassettes'
         c.hook_into :webmock
         c.default_cassette_options = { :serialize_with => :json }
+
+        c.before_record do |i|
+          # otherwise Ruby 2.0 will default to UTF-8:
+          i.response.body.force_encoding('US-ASCII')
+        end
       end
 
       VCR.use_cassette('preserve_bytes', :preserve_exact_body_bytes => true) do

data/features/configuration/uri_parser.feature

@@ -59,9 +59,8 @@ Feature: uri_parser
         c.cassette_library_dir = 'cassettes'
       end
 
-      uri = Addressable::URI.parse('http://bad_url.example.com')
       VCR.use_cassette('example') do
-        puts Net::HTTP.get_response(uri).body
+        puts Net::HTTP.get_response('bad_url.example.com', '/').body
       end
       """
      When I run `ruby uri_parser.rb`
@@ -78,9 +77,8 @@ Feature: uri_parser
         c.cassette_library_dir = 'cassettes'
       end
 
-      uri = Addressable::URI.parse('http://bad_url.example.com')
       VCR.use_cassette('example') do
-        puts Net::HTTP.get_response(uri).body
+        puts Net::HTTP.get_response('bad_url.example.com', '/').body
       end
       """
      When I run `ruby uri_parser_default.rb`

data/features/http_libraries/net_http.feature

@@ -144,7 +144,7 @@ Feature: Net::HTTP
           c.cassette_library_dir = 'cassettes'
         end
 
-        uri = URI("https://raw.github.com/gist/fb555cb593f3349d53af/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist")
+        uri = URI("https://gist.github.com/myronmarston/fb555cb593f3349d53af/raw/6921dd638337d3f6a51b0e02e7f30e3c414f70d6/vcr_gist")
 
         VCR.use_cassette('https') do
           http = Net::HTTP.new(uri.host, uri.port)

data/features/request_matching/headers.feature

@@ -83,5 +83,4 @@ Feature: Matching on Headers
       | c.hook_into :webmock  | curb                  |
       | c.hook_into :webmock  | patron                |
       | c.hook_into :webmock  | em-http-request       |
-      | c.hook_into :excon    | excon                 |
 

data/features/step_definitions/cli_steps.rb

@@ -31,6 +31,7 @@ module VCRHelpers
       i.request.body ||= ''
       i.response.body ||= ''
       i.response.status.message ||= ''
+      i.response.adapter_metadata.clear
 
       # Remove non-deterministic headers and headers
       # that get added by a particular HTTP library (but not by others)
@@ -168,10 +169,6 @@ Then /^the file "([^"]*)" should contain each of these:$/ do |file_name, table|
   end
 end
 
-Then /^the file "([^"]*)" should contain:$/ do |file_name, expected_content|
-  check_file_content(file_name, expected_content, true)
-end
-
 Then /^the file "([^"]*)" should contain a YAML fragment like:$/ do |file_name, fragment|
   in_current_dir do
     file_content = File.read(file_name)

data/features/test_frameworks/cucumber.feature

@@ -149,3 +149,62 @@ Feature: Usage with Cucumber
     And the file "features/cassettes/allowed.yml" should contain "Hello allowed"
     And the file "features/cassettes/VCR_example/tagged_scenario.yml" should contain "Hello localhost_request_1"
     And the file "features/cassettes/VCR_example/tagged_scenario_outline/_foo_bar_.yml" should contain "Hello localhost_request_1"
+
+  Scenario: `:allow_unused_http_interactions => false` does not raise if the scenario already failed
+    Given a previously recorded cassette file "features/cassettes/cucumber_tags/example.yml" with:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: get
+          uri: http://example.com/foo
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "5"
+          body: 
+            encoding: UTF-8
+            string: Hello
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
+      """
+    And a file named "features/support/vcr.rb" with:
+      """ruby
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'features/cassettes'
+      end
+
+      VCR.cucumber_tags do |t|
+        t.tag '@example', :allow_unused_http_interactions => false
+      end
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """ruby
+      When /^the scenario fails$/ do
+        raise "boom"
+      end
+      """
+    And a file named "features/vcr_example.feature" with:
+      """
+      Feature:
+
+        @example
+        Scenario: tagged scenario
+          When the scenario fails
+      """
+    When I run `cucumber features/vcr_example.feature`
+    Then it should fail with "1 scenario (1 failed)"
+     And the output should contain "boom"
+     And the output should not contain "There are unused HTTP interactions"
+