vcr 2.0.0.beta1 → 2.0.0.beta2

data/features/request_matching/uri_without_param.feature

@@ -16,37 +16,39 @@ Feature: URI without param(s)
   Background:
     Given a previously recorded cassette file "cassettes/example.yml" with:
       """
-      --- 
-      - !ruby/struct:VCR::HTTPInteraction 
-        request: !ruby/struct:VCR::Request 
-          method: :get
-          uri: http://example.com:80/search?q=foo&timestamp=1316920490
-          body: 
-          headers: 
-        response: !ruby/struct:VCR::Response 
-          status: !ruby/struct:VCR::ResponseStatus 
+      ---
+      http_interactions:
+      - request:
+          method: get
+          uri: http://example.com/search?q=foo&timestamp=1316920490
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
-          headers: 
-            content-length: 
-            - "12"
+          headers:
+            Content-Length:
+            - '12'
           body: foo response
-          http_version: "1.1"
-      - !ruby/struct:VCR::HTTPInteraction 
-        request: !ruby/struct:VCR::Request 
-          method: :get
-          uri: http://example.com:80/search?q=bar&timestamp=1296723437
-          body: 
-          headers: 
-        response: !ruby/struct:VCR::Response 
-          status: !ruby/struct:VCR::ResponseStatus 
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      - request:
+          method: get
+          uri: http://example.com/search?q=bar&timestamp=1296723437
+          body: ''
+          headers: {}
+        response:
+          status:
             code: 200
             message: OK
-          headers: 
-            content-length: 
-            - "12"
+          headers:
+            Content-Length:
+            - '12'
           body: bar response
-          http_version: "1.1"
+          http_version: '1.1'
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
       """
 
   Scenario: Match the URI on all but the timestamp query parameter
@@ -65,7 +67,7 @@ Feature: URI without param(s)
       end
 
       def search_uri(q)
-        "http://example.com:80/search?q=#{q}&timestamp=#{Time.now.to_i}"
+        "http://example.com/search?q=#{q}&timestamp=#{Time.now.to_i}"
       end
 
       VCR.use_cassette('example') do

data/features/step_definitions/cli_steps.rb

@@ -1,26 +1,66 @@
 require 'vcr'
+require 'multi_json'
 
 module VCRHelpers
 
-  def normalize_cassette_structs(content)
-    structs = YAML.load(content)
+  def normalize_cassette_hash(cassette_hash)
+    cassette_hash['recorded_with'] = "VCR #{VCR.version}"
+    cassette_hash['http_interactions'].map! { |h| normalize_http_interaction(h) }
+    cassette_hash
+  end
 
-    # Remove non-deterministic headers
-    structs.each do |s|
-      s.response.headers.reject! { |k, v| %w[ server date ].include?(k) }
+  def normalize_headers(object)
+    object.headers = {} and return if object.headers.nil?
+    object.headers = {}.tap do |hash|
+      object.headers.each do |key, value|
+        hash[key.downcase] = value
+      end
     end
+  end
+
+  def static_timestamp
+    @static_timestamp ||= Time.now
+  end
+
+  def normalize_http_interaction(hash)
+    VCR::HTTPInteraction.from_hash(hash).tap do |i|
+      normalize_headers(i.request)
+      normalize_headers(i.response)
+
+      i.recorded_at &&= static_timestamp
+      i.request.body ||= ''
+      i.response.body ||= ''
+      i.response.status.message ||= ''
+
+      # Remove non-deterministic headers and headers
+      # that get added by a particular HTTP library (but not by others)
+      i.response.headers.reject! { |k, v| %w[ server date connection ].include?(k) }
+      i.request.headers.reject! { |k, v| %w[ accept user-agent connection expect ].include?(k) }
+
+      # Some HTTP libraries include an extra space ("OK " instead of "OK")
+      i.response.status.message = i.response.status.message.strip
 
-    case @stubbing_lib_for_current_scenario
-      when /excon|faraday/
+      if @scenario_parameters.to_s =~ /excon|faraday/
         # Excon/Faraday do not expose the status message or http version,
         # so we have no way to record these attributes.
-        structs.each do |s|
-          s.response.status.message = nil
-          s.response.http_version = nil
-        end
+        i.response.status.message = nil
+        i.response.http_version = nil
+      elsif @scenario_parameters.to_s.include?('webmock')
+        # WebMock does not expose the HTTP version so we have no way to record it
+        i.response.http_version = nil
+      end
     end
+  end
 
-    structs
+  def normalize_cassette_content(content)
+    return content unless @scenario_parameters.to_s.include?('patron')
+    cassette_hash = YAML.load(content)
+    cassette_hash['http_interactions'].map! do |hash|
+      VCR::HTTPInteraction.from_hash(hash).tap do |i|
+        i.request.headers = (i.request.headers || {}).merge!('Expect' => [''])
+      end.to_hash
+    end
+    YAML.dump(cassette_hash)
   end
 
   def modify_file(file_name, orig_text, new_text)
@@ -45,11 +85,11 @@ Given /^the directory "([^"]*)" does not exist$/ do |dir|
 end
 
 Given /^a previously recorded cassette file "([^"]*)" with:$/ do |file_name, content|
-  write_file(file_name, content)
+  write_file(file_name, normalize_cassette_content(content))
 end
 
-Given /^(\d+) days have passed since the cassette was recorded$/ do |day_count|
-  set_env('DAYS_PASSED', day_count)
+Given /^it is (.*)$/ do |date_string|
+  set_env('DATE_STRING', date_string)
 end
 
 When /^I modify the file "([^"]*)" to replace "([^"]*)" with "([^"]*)"$/ do |file_name, orig_text, new_text|
@@ -76,7 +116,21 @@ end
 
 Then /^the file "([^"]*)" should contain YAML like:$/ do |file_name, expected_content|
   actual_content = in_current_dir { File.read(file_name) }
-  normalize_cassette_structs(actual_content).should == normalize_cassette_structs(expected_content)
+  normalize_cassette_hash(YAML.load(actual_content)).should == normalize_cassette_hash(YAML.load(expected_content))
+end
+
+Then /^the file "([^"]*)" should contain JSON like:$/ do |file_name, expected_content|
+  actual_content = in_current_dir { File.read(file_name) }
+  actual = MultiJson.decode(actual_content)
+  expected = MultiJson.decode(expected_content)
+  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
+end
+
+Then /^the file "([^"]*)" should contain ruby like:$/ do |file_name, expected_content|
+  actual_content = in_current_dir { File.read(file_name) }
+  actual = eval(actual_content)
+  expected = eval(expected_content)
+  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
 end
 
 Then /^the file "([^"]*)" should contain each of these:$/ do |file_name, table|
@@ -103,7 +157,7 @@ Then /^the file "([^"]*)" should contain a YAML fragment like:$/ do |file_name,
 end
 
 Then /^the cassette "([^"]*)" should have the following response bodies:$/ do |file, table|
-  interactions = in_current_dir { YAML.load_file(file) }
+  interactions = in_current_dir { YAML.load_file(file) }['http_interactions'].map { |h| VCR::HTTPInteraction.from_hash(h) }
   actual_response_bodies = interactions.map { |i| i.response.body }
   expected_response_bodies = table.raw.flatten
   actual_response_bodies.should =~ expected_response_bodies

data/features/support/env.rb

@@ -2,6 +2,8 @@ require 'rubygems'
 require 'bundler'
 Bundler.setup
 
+require 'ruby-debug' if !defined?(RUBY_ENGINE) && RUBY_VERSION != '1.9.3' && !ENV['CI']
+
 require 'aruba/cucumber'
 
 cucumer_helpers_file = '../../features/support/vcr_cucumber_helpers'
@@ -24,6 +26,6 @@ else
 end
 
 Before do
-  @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 60 : 10
+  @aruba_timeout_seconds = RUBY_PLATFORM == 'java' ? 60 : 20
 end
 

data/features/support/http_lib_filters.rb

@@ -18,7 +18,10 @@ elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
   # it's probably a bug in it or rbx...so ignore it, for now.
 
   # I'm getting errors in the curb C extension in rbx.
-  UNSUPPORTED_HTTP_LIBS = %w[ patron em-http-request curb ]
+
+  # Faraday and Typhoeus should be buildable on rbx, but the travis build times out,
+  # so we skip them to speed up the build on travis.
+  UNSUPPORTED_HTTP_LIBS = %w[ patron em-http-request curb faraday typhoeus ]
 elsif RUBY_PLATFORM == 'java'
   # These gems have C extensions and can't install on JRuby.
   c_dependent_libs = %w[ typhoeus patron curb em-http-request ]
@@ -44,8 +47,8 @@ end
 # logic in our step definitions based on the http stubbing library.
 Before do |scenario|
   if scenario.respond_to?(:cell_values)
-    @stubbing_lib_for_current_scenario = scenario.cell_values.find { |v| v =~ /fakeweb|webmock|typhoeus|faraday|excon/ }
+    @scenario_parameters = scenario.cell_values
   else
-    @stubbing_lib_for_current_scenario = nil
+    @scenario_parameters = nil
   end
 end

data/features/support/vcr_cucumber_helpers.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 # This file gets symlinked into the tmp/aruba directory before
 # each scenario so that it is available to be required in them.
 $LOAD_PATH << '../../spec' unless $LOAD_PATH.include?('../../spec')
@@ -15,9 +17,9 @@ if running_under_aruba
   end
 end
 
-if ENV['DAYS_PASSED']
+if ENV['DATE_STRING']
   require 'timecop'
-  Timecop.travel(Time.now + ENV['DAYS_PASSED'].to_i.days)
+  Timecop.travel(Date.parse(ENV['DATE_STRING']))
 end
 
 def include_http_adapter_for(lib)

data/lib/vcr.rb

@@ -1,16 +1,16 @@
 require 'vcr/util/variable_args_block_caller'
-require 'vcr/util/yaml'
 
 require 'vcr/cassette'
+require 'vcr/cassette/serializers'
 require 'vcr/configuration'
 require 'vcr/deprecations'
 require 'vcr/errors'
 require 'vcr/library_hooks'
 require 'vcr/request_ignorer'
 require 'vcr/request_matcher_registry'
+require 'vcr/structs'
 require 'vcr/version'
 
-require 'vcr/structs/http_interaction'
 
 module VCR
   include VariableArgsBlockCaller
@@ -85,6 +85,10 @@ module VCR
     @library_hooks ||= LibraryHooks.new
   end
 
+  def cassette_serializers
+    @cassette_serializers ||= Cassette::Serializers.new
+  end
+
   def configuration
     @configuration ||= Configuration.new
   end

data/lib/vcr/cassette.rb

@@ -1,21 +1,22 @@
 require 'fileutils'
 require 'erb'
-require 'set'
 
-require 'vcr/cassette/reader'
 require 'vcr/cassette/http_interaction_list'
+require 'vcr/cassette/reader'
+require 'vcr/cassette/serializers'
 
 module VCR
   class Cassette
     VALID_RECORD_MODES = [:all, :none, :new_episodes, :once]
 
-    attr_reader :name, :record_mode, :match_requests_on, :erb, :re_record_interval, :tag, :http_interactions
+    attr_reader :name, :record_mode, :match_requests_on, :erb, :re_record_interval, :tag
 
     def initialize(name, options = {})
       options = VCR.configuration.default_cassette_options.merge(options)
       invalid_options = options.keys - [
         :record, :erb, :match_requests_on, :re_record_interval, :tag,
-        :update_content_length_header, :allow_playback_repeats, :exclusive
+        :update_content_length_header, :allow_playback_repeats, :exclusive,
+        :serialize_with
       ]
 
       if invalid_options.size > 0
@@ -28,22 +29,44 @@ module VCR
       @match_requests_on            = options[:match_requests_on]
       @re_record_interval           = options[:re_record_interval]
       @tag                          = options[:tag]
-      @record_mode                  = :all if should_re_record?
       @update_content_length_header = options[:update_content_length_header]
       @allow_playback_repeats       = options[:allow_playback_repeats]
       @exclusive                    = options[:exclusive]
+      @serializer                   = VCR.cassette_serializers[options[:serialize_with]]
+      @record_mode                  = :all if should_re_record?
+      @parent_list                  = @exclusive ? HTTPInteractionList::NullList.new : VCR.http_interactions
 
       raise_error_unless_valid_record_mode
-
-      load_recorded_interactions
     end
 
     def eject
       write_recorded_interactions_to_disk
     end
 
-    def recorded_interactions
-      @recorded_interactions ||= []
+    def previously_recorded_interactions
+      @previously_recorded_interactions ||= if file && File.size?(file)
+        deserialized_hash['http_interactions'].map { |h| HTTPInteraction.from_hash(h) }.tap do |interactions|
+          invoke_hook(:before_playback, interactions)
+
+          interactions.reject! do |i|
+            i.request.uri.is_a?(String) && VCR.request_ignorer.ignore?(i.request)
+          end
+
+          if update_content_length_header?
+            interactions.each { |i| i.response.update_content_length_header }
+          end
+        end
+      else
+        []
+      end
+    end
+
+    def http_interactions
+      @http_interactions ||= HTTPInteractionList.new \
+        should_stub_requests? ? previously_recorded_interactions : [],
+        match_requests_on,
+        @allow_playback_repeats,
+        @parent_list
     end
 
     def record_http_interaction(interaction)
@@ -55,7 +78,8 @@ module VCR
     end
 
     def file
-      File.join(VCR.configuration.cassette_library_dir, "#{sanitized_name}.yml") if VCR.configuration.cassette_library_dir
+      return nil unless VCR.configuration.cassette_library_dir
+      File.join(VCR.configuration.cassette_library_dir, "#{sanitized_name}.#{@serializer.file_extension}")
     end
 
     def update_content_length_header?
@@ -70,6 +94,13 @@ module VCR
       end
     end
 
+    def serializable_hash
+      {
+        "http_interactions" => interactions_to_record.map(&:to_hash),
+        "recorded_with"     => "VCR #{VCR.version}"
+      }
+    end
+
   private
 
     def sanitized_name
@@ -83,10 +114,16 @@ module VCR
     end
 
     def should_re_record?
-      @re_record_interval &&
-      File.exist?(file) &&
-      File.stat(file).mtime + @re_record_interval < Time.now &&
-      InternetConnection.available?
+      return false unless @re_record_interval
+      return false unless earliest_interaction_recorded_at
+      return false unless File.exist?(file)
+      return false unless InternetConnection.available?
+
+      earliest_interaction_recorded_at + @re_record_interval < Time.now
+    end
+
+    def earliest_interaction_recorded_at
+      previously_recorded_interactions.map(&:recorded_at).min
     end
 
     def should_stub_requests?
@@ -97,42 +134,12 @@ module VCR
       record_mode == :all
     end
 
-    def load_recorded_interactions
-      if file && File.size?(file)
-        interactions = VCR::YAML.load(raw_yaml_content)
-
-        invoke_hook(:before_playback, interactions)
-
-        interactions.reject! do |i|
-          i.request.uri.is_a?(String) && VCR.request_ignorer.ignore?(i.request)
-        end
-
-        if update_content_length_header?
-          interactions.each { |i| i.response.update_content_length_header }
-        end
-
-        recorded_interactions.replace(interactions)
-      end
-
-      interactions = should_stub_requests? ? recorded_interactions : []
-
-      @http_interactions = HTTPInteractionList.new(
-        interactions,
-        match_requests_on,
-        @allow_playback_repeats,
-        parent_list)
-    end
-
-    def parent_list
-      @exclusive ? HTTPInteractionList::NullList.new : VCR.http_interactions
-    end
-
     def raw_yaml_content
       VCR::Cassette::Reader.new(file, erb).read
     end
 
     def merged_interactions
-      old_interactions = recorded_interactions
+      old_interactions = previously_recorded_interactions
 
       if should_remove_matching_existing_interactions?
         new_interaction_list = HTTPInteractionList.new(new_recorded_interactions, match_requests_on)
@@ -144,17 +151,21 @@ module VCR
       old_interactions + new_recorded_interactions
     end
 
+    def interactions_to_record
+      merged_interactions.tap do |interactions|
+        invoke_hook(:before_record, interactions)
+      end
+    end
+
     def write_recorded_interactions_to_disk
       return unless VCR.configuration.cassette_library_dir
-      return if new_recorded_interactions.empty?
-
-      interactions = merged_interactions
-      invoke_hook(:before_record, interactions)
-      return if interactions.empty?
+      return if new_recorded_interactions.none?
+      hash = serializable_hash
+      return if hash["http_interactions"].none?
 
       directory = File.dirname(file)
       FileUtils.mkdir_p directory unless File.exist?(directory)
-      File.open(file, 'w') { |f| f.write VCR::YAML.dump(interactions) }
+      File.open(file, 'w') { |f| f.write @serializer.serialize(hash) }
     end
 
     def invoke_hook(type, interactions)
@@ -163,5 +174,18 @@ module VCR
         i.ignored?
       end
     end
+
+    def deserialized_hash
+      @deserialized_hash ||= @serializer.deserialize(raw_yaml_content).tap do |hash|
+        unless hash.is_a?(Hash) && hash['http_interactions'].is_a?(Array)
+          raise Errors::InvalidCassetteFormatError.new \
+            "#{file} does not appear to be a valid VCR 2.0 cassette. " +
+            "VCR 1.x cassettes are not valid with VCR 2.0. When upgrading from " +
+            "VCR 1.x, it is recommended that you delete all your existing cassettes and " +
+            "re-record them, or use the provided vcr:migrate_cassettes rake task to migrate " +
+            "them. For more info, see the VCR upgrade guide."
+        end
+      end
+    end
   end
 end