vcr 1.1.2 → 1.2.0

data/features/step_definitions/net_http_steps.rb

@@ -1,3 +1,5 @@
+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|
@@ -34,4 +36,14 @@ 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
+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

@@ -74,9 +74,11 @@ module VCRHelpers
   end
 
   def recorded_interactions_for(cassette_name)
-    yaml_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-    yaml = File.open(yaml_file, 'r') { |f| f.read }
-    interactions = YAML.load(yaml)
+    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)
@@ -95,12 +97,11 @@ end
 World(VCRHelpers)
 
 Given /^we do not have a "([^\"]*)" cassette$/ do |cassette_name|
-  fixture_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-  File.exist?(fixture_file).should be_false
+  File.exist?(file_name(cassette_name)).should be_false
 end
 
-Given /^we have a "([^\"]*)" library file with (a|no) previously recorded response for "([^\"]*)"$/ do |file_name, a_or_no, url|
-  fixture_file = File.join(VCR::Config.cassette_library_dir, "#{file_name}.yml")
+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
@@ -154,7 +155,7 @@ When /^I make an HTTP post request to "([^"]*)" with request header "([^"]*)=([^
   end
 end
 
-When /^I make (.*) requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"]*)" cassette(?: using cassette options: (.*))?$/ do |http_request_type, url1, url2, cassette_name, options|
+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
@@ -164,23 +165,24 @@ When /^I make (.*) requests? to "([^\"]*)"(?: and "([^\"]*)")? within the "([^\"
   end
 end
 
-When /^I make an HTTP post request to "([^"]*)" with request body "([^"]*)" within the "([^"]*)" cassette(?: using cassette options: (.*))?$/ do |url, request_body, cassette_name, options|
+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 "([^"]*)=([^"]*)" within the "([^"]*)" cassette(?: using cassette options: (.*))?$/ do |url, header_key, header_value, cassette_name, options|
+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 have a response for "([^\"]*)" that matches \/(.+)\/$/ do |cassette_name, url, regex_str|
+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.should have_expected_response(regex_str, :url => url)
+  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|
@@ -216,8 +218,7 @@ Then /^(?:the )?response(?: (\d+))? for "([^\"]*)" should match \/(.+)\/$/ do |r
 end
 
 Then /^there should not be a "([^\"]*)" library file$/ do |cassette_name|
-  yaml_file = File.join(VCR::Config.cassette_library_dir, "#{cassette_name}.yml")
-  File.exist?(yaml_file).should be_false
+  File.exist?(file_name(cassette_name)).should be_false
 end
 
 Given /^the ignore_localhost config setting is set to (true|false)$/ do |value|
@@ -228,8 +229,8 @@ Given /^a rack app is running on localhost that returns "([^"]+)" for all reques
   @rack_server = static_rack_server(response_string)
 end
 
-When /^I make an HTTP get request to the localhost rack app within the "([^\"]*)" cassette$/ do |cassette|
-  When %{I make an HTTP get request to "http://localhost:#{@rack_server.port}/" within the "#{cassette}" cassette}
+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|
@@ -240,3 +241,12 @@ Given /^the "([^\"]*)" library file has a response for localhost that matches \/
   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

data/features/support/env.rb

@@ -19,12 +19,17 @@ World(HTTP_LIBRARY_ADAPTERS[ENV['HTTP_LIB']])
 puts "\n\n---------------- Running features using #{ENV['HTTP_STUBBING_ADAPTER']} and #{ENV['HTTP_LIB']} -----------------\n"
 
 require 'vcr'
+require 'ruby_interpreter'
 require 'vcr_localhost_server'
+require 'fixnum_extension'
 
 require 'rubygems'
 require 'bundler'
 Bundler.setup
 
+require 'aruba'
+require 'timecop'
+
 begin
   require 'ruby-debug'
   Debugger.start
@@ -52,6 +57,7 @@ VCR.module_eval do
 end
 
 After do |scenario|
+  Timecop.return
   if raised_error = (@http_requests || {}).values.flatten.detect { |result| result.is_a?(Exception) && result.message !~ /VCR/ }
     raise raised_error
   end
@@ -66,11 +72,13 @@ Before do |scenario|
   FileUtils.rm_rf(temp_dir) if File.exist?(temp_dir)
 end
 
-Before('@copy_not_the_real_response_to_temp') do
-  orig_file = File.join(VCR::Config.cassette_library_dir, 'not_the_real_response.yml')
-  temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', 'not_the_real_response.yml')
-  FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
-  FileUtils.cp orig_file, temp_file
+%w[not_the_real_response record_all].each do |cassette|
+  Before("@copy_#{cassette}_to_temp") do
+    orig_file = File.join(VCR::Config.cassette_library_dir, "#{cassette}.yml")
+    temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', "#{cassette}.yml")
+    FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
+    FileUtils.cp orig_file, temp_file
+  end
 end
 
 Before('@create_replay_localhost_cassette') do

data/features/webmock.feature

@@ -6,21 +6,21 @@ Feature: Replay recorded response
 
   Scenario: Use the :match_requests_on option to differentiate requests by request body (for "foo=bar")
     Given the "match_requests_on" library file has a response for "http://example.com/" with the request body "foo=bar" that matches /foo=bar response/
-     When I make an HTTP post request to "http://example.com/" with request body "foo=bar" within the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :body], :record => :none }
+     When I make an HTTP post request to "http://example.com/" with request body "foo=bar" while using the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :body], :record => :none }
      Then the response for "http://example.com/" should match /foo=bar response/
 
   Scenario: Use the :match_requests_on option to differentiate requests by request body (for "bar=bazz")
     Given the "match_requests_on" library file has a response for "http://example.com/" with the request body "bar=bazz" that matches /bar=bazz response/
-     When I make an HTTP post request to "http://example.com/" with request body "bar=bazz" within the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :body], :record => :none }
+     When I make an HTTP post request to "http://example.com/" with request body "bar=bazz" while using the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :body], :record => :none }
      Then the response for "http://example.com/" should match /bar=bazz response/
 
   Scenario: Use the :match_requests_on option to differentiate requests by request header (for "X-HTTP-USER=joe")
     Given the "match_requests_on" library file has a response for "http://example.com/" with the request header "X-HTTP-USER=joe" that matches /joe response/
-     When I make an HTTP post request to "http://example.com/" with request header "X-HTTP-USER=joe" within the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :headers], :record => :none }
+     When I make an HTTP post request to "http://example.com/" with request header "X-HTTP-USER=joe" while using the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :headers], :record => :none }
      Then the response for "http://example.com/" should match /joe response/
 
   Scenario: Use the :match_requests_on option to differentiate requests by request header (for "X-HTTP-USER=bob")
     Given the "match_requests_on" library file has a response for "http://example.com/" with the request header "X-HTTP-USER=bob" that matches /bob response/
-     When I make an HTTP post request to "http://example.com/" with request header "X-HTTP-USER=bob" within the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :headers], :record => :none }
+     When I make an HTTP post request to "http://example.com/" with request header "X-HTTP-USER=bob" while using the "match_requests_on" cassette using cassette options: { :match_requests_on => [:uri, :headers], :record => :none }
      Then the response for "http://example.com/" should match /bob response/
 

data/lib/vcr.rb

@@ -1,19 +1,19 @@
 require 'vcr/cassette'
 require 'vcr/config'
-require 'vcr/cucumber_tags'
 require 'vcr/deprecations'
 require 'vcr/request_matcher'
 require 'vcr/structs'
 require 'vcr/version'
-
-require 'vcr/extensions/net_http_response'
-
 require 'vcr/http_stubbing_adapters/common'
 
 module VCR
   extend self
 
-  LOCALHOST_ALIASES = %w( localhost 127.0.0.1 )
+  autoload :CucumberTags,       'vcr/cucumber_tags'
+  autoload :InternetConnection, 'vcr/internet_connection'
+  autoload :RSpec,              'vcr/rspec'
+
+  LOCALHOST_ALIASES = %w( localhost 127.0.0.1 0.0.0.0 )
 
   def current_cassette
     cassettes.last

data/lib/vcr/cassette.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'yaml'
 require 'erb'
+require 'set'
 
 module VCR
   class Cassette
@@ -12,13 +13,18 @@ module VCR
 
     def initialize(name, options = {})
       options = VCR::Config.default_cassette_options.merge(options)
-      invalid_options = options.keys - [:record, :erb, :allow_real_http, :match_requests_on]
+      invalid_options = options.keys - [:record, :erb, :allow_real_http, :match_requests_on, :re_record_interval]
 
       if invalid_options.size > 0
         raise ArgumentError.new("You passed the following invalid options to VCR::Cassette.new: #{invalid_options.inspect}.")
       end
 
-      @name, @record_mode, @erb, @match_requests_on = name, options[:record], options[:erb], options[:match_requests_on]
+      @name               = name
+      @record_mode        = options[:record]
+      @erb                = options[:erb]
+      @match_requests_on  = options[:match_requests_on]
+      @re_record_interval = options[:re_record_interval]
+      @record_mode        = :all if should_re_record?
 
       deprecate_old_cassette_options(options)
       raise_error_unless_valid_record_mode(record_mode)
@@ -39,7 +45,11 @@ module VCR
     end
 
     def record_http_interaction(interaction)
-      recorded_interactions << interaction
+      new_recorded_interactions << interaction
+    end
+
+    def new_recorded_interactions
+      @new_recorded_interactions ||= []
     end
 
     def file
@@ -58,12 +68,23 @@ module VCR
       end
     end
 
-    def new_recorded_interactions
-      recorded_interactions - @original_recorded_interactions
+    def should_re_record?
+      @re_record_interval &&
+      File.exist?(file) &&
+      File.stat(file).mtime + @re_record_interval < Time.now &&
+      InternetConnection.available?
     end
 
     def should_allow_http_connections?
-      [:new_episodes, :all].include?(record_mode)
+      record_mode != :none
+    end
+
+    def should_stub_requests?
+      record_mode != :all
+    end
+
+    def should_remove_matching_existing_interactions?
+      record_mode == :all
     end
 
     def set_http_connections_allowed
@@ -77,11 +98,9 @@ module VCR
 
     def load_recorded_interactions
       VCR.http_stubbing_adapter.create_stubs_checkpoint(name)
-      @original_recorded_interactions = []
-      return if record_mode == :all
 
-      if file
-        @original_recorded_interactions = begin
+      if file && File.exist?(file)
+        begin
           interactions = YAML.load(raw_yaml_content)
 
           if VCR.http_stubbing_adapter.ignore_localhost?
@@ -90,16 +109,16 @@ module VCR
             end
           end
 
-          interactions
+          recorded_interactions.replace(interactions)
         rescue TypeError
           raise unless raw_yaml_content =~ /VCR::RecordedResponse/
           raise "The VCR cassette #{sanitized_name}.yml uses an old format that is now deprecated.  VCR provides a rake task to migrate your old cassettes to the new format.  See http://github.com/myronmarston/vcr/blob/master/CHANGELOG.md for more info."
-        end if File.exist?(file)
-
-        recorded_interactions.replace(@original_recorded_interactions)
+        end
       end
 
-      VCR.http_stubbing_adapter.stub_requests(recorded_interactions, match_requests_on)
+      if should_stub_requests?
+        VCR.http_stubbing_adapter.stub_requests(recorded_interactions, match_requests_on)
+      end
     end
 
     @@struct_cache = Hash.new do |hash, attributes|
@@ -121,21 +140,38 @@ module VCR
         # instance_eval seems to be the only way to get the binding for ruby 1.9: http://redmine.ruby-lang.org/issues/show/2161
         template.result(local_variables.instance_eval { binding })
       rescue NameError => e
-        var_name = e.message[/undefined local variable or method `(.*)' for/, 1].to_sym
-        example_hash = (@erb.is_a?(Hash) ? @erb : {}).merge(var_name => 'some value')
+        example_hash = (@erb.is_a?(Hash) ? @erb : {}).merge(e.name => 'some value')
 
         raise MissingERBVariableError.new(
-          "The ERB in the #{sanitized_name}.yml cassette file references undefined variable #{var_name}.  " +
+          "The ERB in the #{sanitized_name}.yml cassette file references undefined variable #{e.name}.  " +
           "Pass it to the cassette using :erb => #{ example_hash.inspect }."
         )
       end
     end
 
+    def merged_interactions
+      old_interactions = recorded_interactions
+
+      if should_remove_matching_existing_interactions?
+        match_attributes = match_requests_on
+
+        new_request_matchers = Set.new new_recorded_interactions.map do |i|
+          i.request.matcher(match_attributes)
+        end
+
+        old_interactions = old_interactions.reject do |i|
+          new_request_matchers.include?(i.request.matcher(match_attributes))
+        end
+      end
+
+      old_interactions + new_recorded_interactions
+    end
+
     def write_recorded_interactions_to_disk
       if VCR::Config.cassette_library_dir && new_recorded_interactions.size > 0
         directory = File.dirname(file)
         FileUtils.mkdir_p directory unless File.exist?(directory)
-        File.open(file, 'w') { |f| f.write recorded_interactions.to_yaml }
+        File.open(file, 'w') { |f| f.write merged_interactions.to_yaml }
       end
     end
   end

data/lib/vcr/extensions/net_http.rb

@@ -1,4 +1,5 @@
 require 'net/http'
+require 'vcr/extensions/net_http_response'
 
 module Net
   class HTTP
@@ -9,10 +10,7 @@ module Net
       match_attributes = (cass = VCR.current_cassette) ? cass.match_requests_on : VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES
       if started? && !VCR.http_stubbing_adapter.request_stubbed?(vcr_request, match_attributes)
         VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, VCR::Response.from_net_http_response(response))
-
-        if VCR.http_stubbing_adapter.should_unwind_response?(response)
-          response.extend VCR::Net::HTTPResponse # "unwind" the response
-        end
+        response.extend VCR::Net::HTTPResponse # "unwind" the response
       end
 
       yield response if block_given?

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -64,10 +64,6 @@ module VCR
         @ignore_localhost
       end
 
-      def should_unwind_response?(response)
-        true
-      end
-
       private
 
       def version

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -1,5 +1,4 @@
 require 'webmock'
-require 'vcr/extensions/net_http'
 
 module VCR
   module HttpStubbingAdapters
@@ -7,7 +6,7 @@ module VCR
       include VCR::HttpStubbingAdapters::Common
       extend self
 
-      VERSION_REQUIREMENT = '1.3.3'
+      VERSION_REQUIREMENT = '1.4.0'
 
       def http_connections_allowed?
         ::WebMock::Config.instance.allow_net_connect
@@ -59,12 +58,6 @@ module VCR
         ::WebMock::Config.instance.allow_localhost
       end
 
-      def should_unwind_response?(response)
-        class << response
-          !ancestors.include?(::WebMock::Net::HTTPResponse)
-        end
-      end
-
       private
 
       def version
@@ -93,7 +86,7 @@ module VCR
   end
 end
 
-WebMock.after_request(:except => [:net_http], :real_requests_only => true) do |request, response|
+WebMock.after_request(:real_requests_only => true) do |request, response|
   http_interaction = VCR::HTTPInteraction.new(
     VCR::Request.new(
       request.method,

data/lib/vcr/internet_connection.rb

@@ -0,0 +1,13 @@
+require 'vcr/ping'
+
+module VCR
+  module InternetConnection
+    extend self
+
+    EXAMPLE_HOST = "example.com"
+
+    def available?
+      @available ||= Ping.pingecho(EXAMPLE_HOST, 1, 80)
+    end
+  end
+end