vcr 3.0.3 → 6.2.0

data/lib/vcr/library_hooks/excon.rb

@@ -22,6 +22,14 @@ VCR.configuration.after_library_hooks_loaded do
   # (i.e. to double record requests or whatever).
   if defined?(WebMock::HttpLibAdapters::ExconAdapter)
     WebMock::HttpLibAdapters::ExconAdapter.disable!
+
+    if defined?(::RSpec)
+      ::RSpec.configure do |config|
+        config.before(:suite) do
+          WebMock::HttpLibAdapters::ExconAdapter.disable!
+        end
+      end
+    end
   end
 end
 

data/lib/vcr/library_hooks/typhoeus.rb

@@ -2,79 +2,72 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'typhoeus'
 
-if Float(Typhoeus::VERSION[/^\d+\.\d+/]) < 0.5
-  require 'vcr/library_hooks/typhoeus_0.4'
-else
-  VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.5.0').check_version!
-
-  module VCR
-    class LibraryHooks
+module VCR
+  class LibraryHooks
+    # @private
+    module Typhoeus
       # @private
-      module Typhoeus
-        # @private
-        class RequestHandler < ::VCR::RequestHandler
-          attr_reader :request
-          def initialize(request)
-            @request = request
-            request.block_connection = false if VCR.turned_on?
-          end
-
-          def vcr_request
-            @vcr_request ||= VCR::Request.new \
-              request.options.fetch(:method, :get),
-              request.url,
-              request_body,
-              request.options.fetch(:headers, {})
-          end
+      class RequestHandler < ::VCR::RequestHandler
+        attr_reader :request
+        def initialize(request)
+          @request = request
+          request.block_connection = false if VCR.turned_on?
+        end
 
-        private
+        def vcr_request
+          @vcr_request ||= VCR::Request.new \
+            request.options.fetch(:method, :get),
+            request.url,
+            request.encoded_body,
+            request.options.fetch(:headers, {})
+        end
 
-          def externally_stubbed?
-            ::Typhoeus::Expectation.find_by(request)
-          end
+      private
 
-          def set_typed_request_for_after_hook(*args)
-            super
-            request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
-          end
+        def externally_stubbed?
+          ::Typhoeus::Expectation.find_by(request)
+        end
 
-          def on_unhandled_request
-            invoke_after_request_hook(nil)
-            super
-          end
+        def set_typed_request_for_after_hook(*args)
+          super
+          request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
+        end
 
-          def on_stubbed_by_vcr_request
-            ::Typhoeus::Response.new \
-              :http_version   => stubbed_response.http_version,
-              :code           => stubbed_response.status.code,
-              :status_message => stubbed_response.status.message,
-              :headers        => stubbed_response_headers,
-              :body           => stubbed_response.body,
-              :effective_url  => stubbed_response.adapter_metadata.fetch('effective_url', request.url),
-              :mock           => true
-          end
+        def on_unhandled_request
+          invoke_after_request_hook(nil)
+          super
+        end
 
-          def stubbed_response_headers
-            @stubbed_response_headers ||= {}.tap do |hash|
-              stubbed_response.headers.each do |key, values|
-                hash[key] = values.size == 1 ? values.first : values
-              end if stubbed_response.headers
-            end
-          end
+        def on_stubbed_by_vcr_request
+          response = ::Typhoeus::Response.new \
+            :http_version   => stubbed_response.http_version,
+            :code           => stubbed_response.status.code,
+            :status_message => stubbed_response.status.message,
+            :headers        => stubbed_response_headers,
+            :body           => stubbed_response.body,
+            :effective_url  => stubbed_response.adapter_metadata.fetch('effective_url', request.url),
+            :mock           => true
+
+          first_header_line = "HTTP/#{stubbed_response.http_version} #{response.code} #{response.status_message}\r\n"
+          response.instance_variable_set(:@first_header_line, first_header_line)
+          response.instance_variable_get(:@options)[:response_headers] =
+            first_header_line + response.headers.map { |k,v| "#{k}: #{v}"}.join("\r\n")
+
+          response
+        end
 
-          if ::Typhoeus::Request.method_defined?(:encoded_body)
-            def request_body
-              request.encoded_body
-            end
-          else
-            def request_body
-              request.options.fetch(:body, "")
-            end
+        def stubbed_response_headers
+          @stubbed_response_headers ||= {}.tap do |hash|
+            stubbed_response.headers.each do |key, values|
+              hash[key] = values.size == 1 ? values.first : values
+            end if stubbed_response.headers
           end
         end
+      end
 
-        # @private
-        def self.vcr_response_from(response)
+      # @private
+      class << self
+        def vcr_response_from(response)
           VCR::Response.new \
             VCR::ResponseStatus.new(response.code, response.status_message),
             response.headers,
@@ -83,27 +76,47 @@ else
             { "effective_url" => response.effective_url }
         end
 
-        ::Typhoeus.on_complete do |response|
-          request = response.request
-          unless VCR.library_hooks.disabled?(:typhoeus)
-            vcr_response = vcr_response_from(response)
-            typed_vcr_request = request.send(:remove_instance_variable, :@__typed_vcr_request)
-
-            unless request.response.mock
-              http_interaction = VCR::HTTPInteraction.new(typed_vcr_request, vcr_response)
-              VCR.record_http_interaction(http_interaction)
+        def collect_chunks(request)
+          chunks = ''
+          request.on_body.unshift(
+            Proc.new do |body, response|
+              chunks += body
+              request.instance_variable_set(:@chunked_body, chunks)
             end
+          )
+        end
 
-            VCR.configuration.invoke_hook(:after_http_request, typed_vcr_request, vcr_response)
-          end
+        def restore_body_from_chunks(response, request)
+          response.options[:response_body] = request.instance_variable_get(:@chunked_body)
         end
+      end
 
-        ::Typhoeus.before do |request|
-          if response = VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
-            request.finish(response)
-          else
-            true
+      ::Typhoeus.on_complete do |response|
+        request = response.request
+
+        restore_body_from_chunks(response, request) if request.streaming?
+
+        unless VCR.library_hooks.disabled?(:typhoeus)
+          vcr_response = vcr_response_from(response)
+          typed_vcr_request = request.send(:remove_instance_variable, :@__typed_vcr_request)
+
+          unless request.response.mock
+            http_interaction = VCR::HTTPInteraction.new(typed_vcr_request, vcr_response)
+            VCR.record_http_interaction(http_interaction)
           end
+
+          VCR.configuration.invoke_hook(:after_http_request, typed_vcr_request, vcr_response)
+        end
+      end
+
+      ::Typhoeus.before do |request|
+        collect_chunks(request) if request.streaming?
+        if response = VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
+          request.on_headers.each { |cb| cb.call(response) }
+          request.on_body.each { |cb| cb.call(response.body, response) }
+          request.finish(response)
+        else
+          true
         end
       end
     end
@@ -117,4 +130,3 @@ VCR.configuration.after_library_hooks_loaded do
     WebMock::HttpLibAdapters::TyphoeusAdapter.disable!
   end
 end
-

data/lib/vcr/library_hooks/webmock.rb

@@ -12,8 +12,6 @@ module VCR
     module WebMock
       extend self
 
-      @global_hook_disabled_requests = {}
-
       def with_global_hook_disabled(request)
         global_hook_disabled_requests << request
 
@@ -25,19 +23,12 @@ module VCR
       end
 
       def global_hook_disabled?(request)
-        requests = @global_hook_disabled_requests[Thread.current.object_id]
+        requests = Thread.current[:_vcr_webmock_disabled_requests]
         requests && requests.include?(request)
       end
 
       def global_hook_disabled_requests
-        requests = @global_hook_disabled_requests[Thread.current.object_id]
-        return requests if requests
-
-        ObjectSpace.define_finalizer(Thread.current, lambda {
-          @global_hook_disabled_requests.delete(Thread.current.object_id)
-        })
-
-        @global_hook_disabled_requests[Thread.current.object_id] = []
+        Thread.current[:_vcr_webmock_disabled_requests] ||= []
       end
 
       # @private

data/lib/vcr/linked_cassette.rb

@@ -9,8 +9,8 @@ module VCR
       include Enumerable
 
       # Creates a new list of context-owned cassettes and linked cassettes
-      # @param [Array] context-owned cassettes
-      # @param [Array] context-unowned (linked) cassettes
+      # @param cassettes [Array] context-owned cassettes
+      # @param linked_cassettes [Array] context-unowned (linked) cassettes
       def initialize(cassettes, linked_cassettes)
         @cassettes = cassettes
         @linked_cassettes = linked_cassettes
@@ -52,8 +52,8 @@ module VCR
     end
 
     # Create a new CassetteList
-    # @param [Array] context-owned cassettes
-    # @param [Array] context-unowned (linked) cassettes
+    # @param cassettes [Array] context-owned cassettes
+    # @param linked_cassettes [Array] context-unowned (linked) cassettes
     def self.list(cassettes, linked_cassettes)
       CassetteList.new(cassettes, linked_cassettes)
     end

data/lib/vcr/middleware/excon.rb

@@ -74,7 +74,7 @@ module VCR
         def after_request(response)
           vcr_response = vcr_response_for(response)
 
-          if should_record?
+          if vcr_response && should_record?
             VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, vcr_response))
           end
 

data/lib/vcr/middleware/faraday.rb

@@ -31,6 +31,11 @@ module VCR
         RequestHandler.new(@app, env).handle
       end
 
+      # Close any persistent connections.
+      def close
+        @app.close if @app.respond_to?(:close)
+      end
+
       # @private
       class RequestHandler < ::VCR::RequestHandler
         attr_reader :app, :env
@@ -40,9 +45,11 @@ module VCR
         end
 
         def handle
-          # Faraday must be exlusive here in case another library hook is being used.
+          # Faraday must be exclusive here in case another library hook is being used.
           # We don't want double recording/double playback.
           VCR.library_hooks.exclusive_hook = :faraday
+          collect_chunks if env.request.stream_response?
+
           super
         ensure
           response = defined?(@vcr_response) ? @vcr_response : nil
@@ -72,8 +79,12 @@ module VCR
         end
 
         def response_for(response)
+          # reason_phrase is a new addition to Faraday::Response,
+          # so maintain backward compatibility
+          reason = response.respond_to?(:reason_phrase) ? response.reason_phrase : nil
+
           VCR::Response.new(
-            VCR::ResponseStatus.new(response.status, nil),
+            VCR::ResponseStatus.new(response.status, reason),
             response.headers,
             raw_body_from(response.body),
             nil
@@ -94,6 +105,7 @@ module VCR
           @vcr_response = stubbed_response
 
           faraday_response = ::Faraday::Response.new
+          env.request.on_data.call(stubbed_response.body, stubbed_response.body.length) if env.request.stream_response?
           faraday_response.finish(env)
           env[:response] = faraday_response
         end
@@ -102,6 +114,7 @@ module VCR
           @has_on_complete_hook = true
           response = app.call(env)
           response.on_complete do
+            restore_body_from_chunks(env.request) if env.request.stream_response?
             @vcr_response = response_for(response)
             VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, @vcr_response))
             invoke_after_request_hook(@vcr_response) if delay_finishing?
@@ -112,6 +125,20 @@ module VCR
           super
           VCR.library_hooks.exclusive_hook = nil
         end
+
+        def collect_chunks
+          caller_on_data = env.request.on_data
+          chunks = ''
+          env.request.on_data = Proc.new do |chunk, overall_received_bytes|
+            chunks += chunk
+            env.request.instance_variable_set(:@chunked_body, chunks)
+            caller_on_data.call(chunk, overall_received_bytes)
+          end
+        end
+
+        def restore_body_from_chunks(request)
+          env[:body] = request.instance_variable_get(:@chunked_body)
+        end
       end
     end
   end

data/lib/vcr/request_ignorer.rb

@@ -25,10 +25,18 @@ module VCR
       end
     end
 
+    def localhost_ignored?
+      (LOCALHOST_ALIASES & ignore_hosts.to_a).any?
+    end
+
     def ignore_hosts(*hosts)
       ignored_hosts.merge(hosts)
     end
 
+    def unignore_hosts(*hosts)
+      ignored_hosts.subtract(hosts)
+    end
+
     def ignore?(request)
       invoke_hook(:ignore_request, request).any?
     end
@@ -40,4 +48,3 @@ module VCR
     end
   end
 end
-

data/lib/vcr/request_matcher_registry.rb

@@ -110,12 +110,12 @@ module VCR
 
     def register_built_ins
       register(:method)  { |r1, r2| r1.method == r2.method }
-      register(:uri)     { |r1, r2| r1.uri == r2.uri }
+      register(:uri)     { |r1, r2| r1.parsed_uri == r2.parsed_uri }
       register(:body)    { |r1, r2| r1.body == r2.body }
       register(:headers) { |r1, r2| r1.headers == r2.headers }
 
       register(:host) do |r1, r2|
-        r1.parsed_uri.host == r2.parsed_uri.host
+        r1.parsed_uri.host.chomp('.') == r2.parsed_uri.host.chomp('.')
       end
       register(:path) do |r1, r2|
         r1.parsed_uri.path == r2.parsed_uri.path
@@ -138,7 +138,7 @@ module VCR
 
       register(:body_as_json) do |r1, r2|
         begin
-          JSON.parse(r1.body) == JSON.parse(r2.body)
+          r1.body == r2.body || JSON.parse(r1.body) == JSON.parse(r2.body)
         rescue JSON::ParserError
           false
         end

data/lib/vcr/structs.rb

@@ -62,7 +62,7 @@ module VCR
         super
 
         if body && !body.is_a?(String)
-          raise ArgumentError, "#{self.class} initialized with an invalid body: #{body.inspect}."
+          raise ArgumentError, "#{self.class} initialized with an invalid (non-String) body of class #{body.class}: #{body.inspect}."
         end
 
         # Ensure that the body is a raw string, in case the string instance
@@ -167,25 +167,6 @@ module VCR
     end
   end
 
-  # @private
-  module OrderedHashSerializer
-    def each
-      @ordered_keys.each do |key|
-        yield key, self[key] if has_key?(key)
-      end
-    end
-
-    if RUBY_VERSION.to_f > 1.8
-      # 1.9+ hashes are already ordered.
-      def self.apply_to(*args); end
-    else
-      def self.apply_to(hash, keys)
-        hash.instance_variable_set(:@ordered_keys, keys)
-        hash.extend self
-      end
-    end
-  end
-
   # The request of an {HTTPInteraction}.
   #
   # @attr [Symbol] method the HTTP method (i.e. :head, :options, :get, :post, :put, :patch or :delete)
@@ -219,7 +200,7 @@ module VCR
         'uri'     => uri,
         'body'    => serializable_body,
         'headers' => headers
-      }.tap { |h| OrderedHashSerializer.apply_to(h, members) }
+      }
     end
 
     # Constructs a new instance from a hash.
@@ -274,7 +255,7 @@ module VCR
       end
 
       # @return [Boolean] whether or not this request is being stubbed by an
-      #  external library (such as WebMock or FakeWeb).
+      #  external library (such as WebMock).
       # @see #stubbed_by_vcr?
       # @see #stubbed?
       def externally_stubbed?
@@ -365,11 +346,10 @@ module VCR
       {
         'status'       => status.to_hash,
         'headers'      => headers,
-        'body'         => serializable_body,
-        'http_version' => http_version
+        'body'         => serializable_body
       }.tap do |hash|
+        hash['http_version']     = http_version if http_version
         hash['adapter_metadata'] = adapter_metadata unless adapter_metadata.empty?
-        OrderedHashSerializer.apply_to(hash, members)
       end
     end
 
@@ -403,6 +383,11 @@ module VCR
       %w[ gzip deflate ].include? content_encoding
     end
 
+    # Checks if VCR decompressed the response body
+    def vcr_decompressed?
+      adapter_metadata['vcr_decompressed']
+    end
+
     # Decodes the compressed body and deletes evidence that it was ever compressed.
     #
     # @return self
@@ -412,11 +397,43 @@ module VCR
       self.class.decompress(body, content_encoding) { |new_body|
         self.body = new_body
         update_content_length_header
+        adapter_metadata['vcr_decompressed'] = content_encoding
         delete_header('Content-Encoding')
       }
       return self
     end
 
+    # Recompresses the decompressed body according to adapter metadata.
+    #
+    # @raise [VCR::Errors::UnknownContentEncodingError] if the content encoding
+    #  stored in the adapter metadata is unknown
+    def recompress
+      type = adapter_metadata['vcr_decompressed']
+      new_body = begin
+        case type
+        when 'gzip'
+          body_str = ''
+          args = [StringIO.new(body_str)]
+          args << { :encoding => 'ASCII-8BIT' } if ''.respond_to?(:encoding)
+          writer = Zlib::GzipWriter.new(*args)
+          writer.write(body)
+          writer.close
+          body_str
+        when 'deflate'
+          Zlib::Deflate.inflate(body)
+        when 'identity', NilClass
+          nil
+        else
+          raise Errors::UnknownContentEncodingError, "unknown content encoding: #{type}"
+        end
+      end
+      if new_body
+        self.body = new_body
+        update_content_length_header
+        headers['Content-Encoding'] = type
+      end
+    end
+
     begin
       require 'zlib'
       require 'stringio'
@@ -437,9 +454,10 @@ module VCR
 
       case type
       when 'gzip'
-        args = [StringIO.new(body)]
-        args << { :encoding => 'ASCII-8BIT' } if ''.respond_to?(:encoding)
-        yield Zlib::GzipReader.new(*args).read
+        gzip_reader_options = {}
+        gzip_reader_options[:encoding] = 'ASCII-8BIT' if ''.respond_to?(:encoding)
+        yield Zlib::GzipReader.new(StringIO.new(body),
+                                   **gzip_reader_options).read
       when 'deflate'
         yield Zlib::Inflate.inflate(body)
       when 'identity', NilClass
@@ -463,7 +481,7 @@ module VCR
     def to_hash
       {
         'code' => code, 'message' => message
-      }.tap { |h| OrderedHashSerializer.apply_to(h, members) }
+      }
     end
 
     # Constructs a new instance from a hash.
@@ -496,9 +514,7 @@ module VCR
         'request'     => request.to_hash,
         'response'    => response.to_hash,
         'recorded_at' => recorded_at.httpdate
-      }.tap do |hash|
-        OrderedHashSerializer.apply_to(hash, members)
-      end
+      }
     end
 
     # Constructs a new instance from a hash.

data/lib/vcr/test_frameworks/cucumber.rb

@@ -23,10 +23,10 @@ module VCR
     # Adds `Before` and `After` cucumber hooks for the named tags that
     # will cause a VCR cassette to be used for scenarios with matching tags.
     #
-    # @param [Array<String>] tag_names the cucumber scenario tags
-    # @param [(optional) Hash] options the cassette options. Specify
-    #   `:use_scenario_name => true` to automatically name the
-    #   cassette according to the scenario name.
+    # @param tag_names [Array<String,Hash>] the cucumber scenario tags. If
+    #  the last argument is a hash it is treated as cassette options.
+    #   - `:use_scenario_name => true` to automatically name the
+    #     cassette according to the scenario name.
     def tags(*tag_names)
       original_options = tag_names.last.is_a?(::Hash) ? tag_names.pop : {}
       tag_names.each do |tag_name|
@@ -47,10 +47,21 @@ module VCR
                 scenario.scenario_outline.name,
                 scenario.name.split("\n").first
               ].join("/")
-            else
+            elsif scenario.respond_to?(:feature)
               [ scenario.feature.name.split("\n").first,
                 scenario.name.split("\n").first
               ].join("/")
+            elsif scenario.location.lines.min == scenario.location.lines.max
+              # test case from a regular scenario in cucumber version 4
+              [ scenario.location.file.split("/").last.split(".").first,
+                scenario.name.split("\n").first
+              ].join("/")
+            else
+              # test case from a scenario with examples ("scenario outline") in cucumber version 4
+              [ scenario.location.file.split("/").last.split(".").first,
+                scenario.name.split("\n").first,
+                "Example at line #{scenario.location.lines.max}"
+              ].join("/")
             end
           else
             "cucumber_tags/#{tag_name.gsub(/\A@/, '')}"

data/lib/vcr/test_frameworks/rspec.rb

@@ -5,38 +5,50 @@ module VCR
     module Metadata
       extend self
 
+      def vcr_cassette_name_for(metadata)
+        description = 
+          if metadata[:description].empty?
+            # we have an "it { is_expected.to be something }" block
+            metadata[:scoped_id]
+          else
+            metadata[:description]
+          end
+        example_group = 
+          if metadata.key?(:example_group)
+            metadata[:example_group]
+          else
+            metadata[:parent_example_group]
+          end
+
+        if example_group
+          [vcr_cassette_name_for(example_group), description].join('/')
+        else
+          description
+        end
+      end
+
       def configure!
         ::RSpec.configure do |config|
-          vcr_cassette_name_for = lambda do |metadata|
-            description = if metadata[:description].empty?
-                            # we have an "it { is_expected.to be something }" block
-                            metadata[:scoped_id]
-                          else
-                            metadata[:description]
-                          end
-            example_group = if metadata.key?(:example_group)
-                              metadata[:example_group]
-                            else
-                              metadata[:parent_example_group]
-                            end
-
-            if example_group
-              [vcr_cassette_name_for[example_group], description].join('/')
-            else
-              description
-            end
-          end
 
           when_tagged_with_vcr = { :vcr => lambda { |v| !!v } }
 
           config.before(:each, when_tagged_with_vcr) do |ex|
             example = ex.respond_to?(:metadata) ? ex : ex.example
 
+            cassette_name = nil
             options = example.metadata[:vcr]
-            options = options.is_a?(Hash) ? options.dup : {} # in case it's just :vcr => true
+            options = case options
+                      when Hash #=> vcr: { cassette_name: 'foo' }
+                        options.dup
+                      when String #=> vcr: 'bar'
+                        cassette_name = options.dup
+                        {}
+                      else #=> :vcr or vcr: true
+                        {}
+                      end
 
-            cassette_name = options.delete(:cassette_name) ||
-                            vcr_cassette_name_for[example.metadata]
+            cassette_name ||= options.delete(:cassette_name) ||
+                              VCR::RSpec::Metadata.vcr_cassette_name_for(example.metadata)
             VCR.insert_cassette(cassette_name, options)
           end
 

data/lib/vcr/util/hooks.rb

@@ -5,6 +5,7 @@ module VCR
   module Hooks
     include VariableArgsBlockCaller
 
+    # @private
     FilteredHook = Struct.new(:hook, :filters) do
       include VariableArgsBlockCaller