vcr 2.7.0 → 2.8.0

data/lib/vcr.rb

@@ -293,7 +293,7 @@ module VCR
   # @private
   def real_http_connections_allowed?
     return current_cassette.recording? if current_cassette
-    configuration.allow_http_connections_when_no_cassette? || @turned_off
+    !!(configuration.allow_http_connections_when_no_cassette? || @turned_off)
   end
 
   # @return [RequestMatcherRegistry] the request matcher registry

data/lib/vcr/errors.rb

@@ -77,14 +77,34 @@ module VCR
       def construct_message
         ["", "", "=" * 80,
          "An HTTP request has been made that VCR does not know how to handle:",
-         "  #{request_description}\n",
+         "#{request_description}\n",
          cassette_description,
          formatted_suggestions,
          "=" * 80, "", ""].join("\n")
       end
 
       def request_description
-        "#{request.method.to_s.upcase} #{request.uri}"
+        lines = []
+
+        lines << "  #{request.method.to_s.upcase} #{request.uri}"
+
+        if match_request_on_body?
+          lines << "  Body: #{request.body}"
+        end
+
+        lines.join("\n")
+      end
+
+      def match_request_on_body?
+        current_matchers.include?(:body)
+      end
+
+      def current_matchers
+        if VCR.current_cassette
+          VCR.current_cassette.match_requests_on
+        else
+          VCR.configuration.default_cassette_options[:match_requests_on]
+        end
       end
 
       def cassette_description

data/lib/vcr/library_hooks/excon.rb

@@ -1,6 +1,21 @@
 require 'vcr/middleware/excon'
 
-Excon.defaults[:middlewares] << VCR::Middleware::Excon
+module VCR
+  class LibraryHooks
+    module Excon
+      # @private
+      def self.configure_middleware
+        middlewares = ::Excon.defaults[:middlewares]
+
+        middlewares << VCR::Middleware::Excon::Request
+        response_parser_index = middlewares.index(::Excon::Middleware::ResponseParser)
+        middlewares.insert(response_parser_index + 1, VCR::Middleware::Excon::Response)
+      end
+
+      configure_middleware
+    end
+  end
+end
 
 VCR.configuration.after_library_hooks_loaded do
   # ensure WebMock's Excon adapter does not conflict with us here

data/lib/vcr/library_hooks/webmock.rb

@@ -114,7 +114,7 @@ module VCR
 
         def on_stubbed_by_vcr_request
           {
-            :body    => stubbed_response.body,
+            :body    => stubbed_response.body.dup, # Excon mutates the body, so we must dup it :-(
             :status  => [stubbed_response.status.code.to_i, stubbed_response.status.message],
             :headers => stubbed_response.headers
           }

data/lib/vcr/middleware/excon.rb

@@ -2,46 +2,50 @@ require 'excon'
 require 'vcr/request_handler'
 require 'vcr/util/version_checker'
 
-VCR::VersionChecker.new('Excon', Excon::VERSION, '0.22.0', '0.28').check_version!
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.25.2', '0.29').check_version!
 
 module VCR
   # Contains middlewares for use with different libraries.
   module Middleware
-    # Excon middleware that uses VCR to record and replay HTTP requests made
-    # through Excon.
-    #
-    # @note You can either add this to the middleware stack of an Excon connection
-    #   yourself, or configure {VCR::Configuration#hook_into} to hook into `:excon`.
-    #   Setting the config option will add this middleware to Excon's default
-    #   middleware stack.
-    class Excon < ::Excon::Middleware::Base
+    # Contains Excon middlewares.
+    module Excon
+      # One part of the Excon middleware that uses VCR to record
+      # and replay HTTP requests made through Excon.
+      #
       # @private
-      def initialize(*args)
-        # Excon appears to create a new instance of this middleware for each
-        # request, which means it should be safe to store per-request state
-        # like this request_handler object on the middleware instance.
-        # I'm not 100% sure about this yet and should verify with @geemus.
-        @request_handler = RequestHandler.new
-        super
-      end
+      class Request < ::Excon::Middleware::Base
+        # @private
+        def request_call(params)
+          params[:vcr_request_handler] = request_handler = RequestHandler.new
+          request_handler.before_request(params)
 
-      # @private
-      def request_call(params)
-        @request_handler.before_request(params)
-        super
+          super
+        end
       end
 
+      # One part of the Excon middleware that uses VCR to record
+      # and replay HTTP requests made through Excon.
+      #
       # @private
-      def response_call(params)
-        @request_handler.after_request(params)
-        super
-      end
+      class Response < ::Excon::Middleware::Base
+        # @private
+        def response_call(params)
+          complete_request(params)
+          super
+        end
 
-      # @private
-      def error_call(params)
-        @request_handler.ensure_response_body_can_be_read_for_error_case
-        @request_handler.after_request(params)
-        super
+        def error_call(params)
+          complete_request(params)
+          super
+        end
+
+      private
+
+        def complete_request(params)
+          if handler = params.delete(:vcr_request_handler)
+            handler.after_request(params[:response])
+          end
+        end
       end
 
       # Handles a single Excon request.
@@ -50,7 +54,6 @@ module VCR
       class RequestHandler < ::VCR::RequestHandler
         def initialize
           @request_params       = nil
-          @response_params      = nil
           @response_body_reader = nil
           @should_record        = false
         end
@@ -65,18 +68,11 @@ module VCR
           handle
         end
 
-        # Performs after_request processing based on the provided
-        # response_params.
+        # Performs after_request processing based on the provided response.
         #
         # @private
-        def after_request(response_params)
-          # If @response_params is already set, it indicates we've already run the
-          # after_request logic. This can happen when if the response triggers an error,
-          # whch would then trigger the error_call middleware callback, leading to this
-          # being called a second time.
-          return if @response_params
-
-          @response_params = response_params
+        def after_request(response)
+          vcr_response = vcr_response_for(response)
 
           if should_record?
             VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, vcr_response))
@@ -92,7 +88,7 @@ module VCR
           @response_body_reader = NonStreamingResponseBodyReader
         end
 
-        attr_reader :request_params, :response_params, :response_body_reader
+        attr_reader :request_params, :response_body_reader
 
       private
 
@@ -106,7 +102,7 @@ module VCR
 
         def on_stubbed_by_vcr_request
           request_params[:response] = {
-            :body     => stubbed_response.body,
+            :body     => stubbed_response.body.dup, # Excon mutates the body, so we must dup it :-(
             :headers  => normalized_headers(stubbed_response.headers || {}),
             :status   => stubbed_response.status.code
           }
@@ -138,21 +134,15 @@ module VCR
           end
         end
 
-        def vcr_response
-          return @vcr_response if defined?(@vcr_response)
+        def vcr_response_for(response)
+          return nil if response.nil?
 
-          if should_record? || response_params.has_key?(:response)
-            response = response_params.fetch(:response)
-
-            @vcr_response = VCR::Response.new(
-              VCR::ResponseStatus.new(response.fetch(:status), nil),
-              response.fetch(:headers),
-              response_body_reader.read_body_from(response),
-              nil
-            )
-          else
-            @vcr_response = nil
-          end
+          VCR::Response.new(
+            VCR::ResponseStatus.new(response.fetch(:status), nil),
+            response.fetch(:headers),
+            response_body_reader.read_body_from(response),
+            nil
+          )
         end
 
         def normalized_headers(headers)
@@ -201,7 +191,14 @@ module VCR
         #
         # @private
         def read_body_from(response_params)
-          @chunks.join('')
+          if @chunks.none?
+            # Not sure why, but sometimes the body comes through the params
+            # instead of via the streaming block even when the block was
+            # configured.
+            response_params[:body]
+          else
+            @chunks.join('')
+          end
         end
       end
 

data/lib/vcr/middleware/excon/legacy_methods.rb

@@ -1,6 +1,6 @@
 module VCR
   module Middleware
-    class Excon
+    module Excon
       # Contains legacy methods only needed when integrating with older versions
       # of Excon.
       # @api private

data/lib/vcr/request_matcher_registry.rb

@@ -125,6 +125,24 @@ module VCR
         VCR.configuration.query_parser.call(r1.parsed_uri.query.to_s) ==
           VCR.configuration.query_parser.call(r2.parsed_uri.query.to_s)
       end
+
+      try_to_register_body_as_json
+    end
+
+    def try_to_register_body_as_json
+      begin
+        require 'json'
+      rescue LoadError
+        return
+      end
+
+      register(:body_as_json) do |r1, r2|
+        begin
+          JSON.parse(r1.body) == JSON.parse(r2.body)
+        rescue JSON::ParserError
+          false
+        end
+      end
     end
   end
 end

data/lib/vcr/test_frameworks/rspec.rb

@@ -20,7 +20,7 @@ module VCR
           when_tagged_with_vcr = { :vcr => lambda { |v| !!v } }
 
           config.before(:each, when_tagged_with_vcr) do |ex|
-            example = respond_to?(:example) ? self.example : ex
+            example = ex.respond_to?(:metadata) ? ex : ex.example
 
             options = example.metadata[:vcr]
             options = options.is_a?(Hash) ? options.dup : {} # in case it's just :vcr => true
@@ -31,7 +31,7 @@ module VCR
           end
 
           config.after(:each, when_tagged_with_vcr) do |ex|
-            example = respond_to?(:example) ? self.example : ex
+            example = ex.respond_to?(:metadata) ? ex : ex.example
             VCR.eject_cassette(:skip_no_unused_interactions_assertion => !!example.exception)
           end
         end

data/lib/vcr/version.rb

@@ -10,7 +10,7 @@ module VCR
   #   * `parts` [Array<Integer>] List of the version parts.
   def version
     @version ||= begin
-      string = '2.7.0'
+      string = '2.8.0'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/script/ci.sh

@@ -13,8 +13,7 @@ bundle install --gemfile=gemfiles/typhoeus_old.gemfile --without extras
 BUNDLE_GEMFILE=gemfiles/typhoeus_old.gemfile bundle exec rspec spec/vcr/library_hooks/typhoeus_0.4_spec.rb --format progress --backtrace
 
 # Setup vendored rspec-1
-git submodule init
-git submodule update
+bundle exec rake submodules
 
 echo "-------- Running Specs ---------"
 bundle exec ruby -I./spec -r./spec/capture_warnings -rspec_helper -S rspec spec --format progress --backtrace

data/spec/monkey_patches.rb

@@ -42,7 +42,7 @@ module MonkeyPatches
           ::Typhoeus::Hydra.stub_finders << finder
         end
       when :excon
-        ::Excon.defaults[:middlewares] << VCR::Middleware::Excon
+        VCR::LibraryHooks::Excon.configure_middleware
       when :vcr
         realias Net::HTTP, :request, :with_vcr
       else raise ArgumentError.new("Unexpected scope: #{scope}")
@@ -69,7 +69,8 @@ module MonkeyPatches
     end
 
     if defined?(::Excon)
-      ::Excon.defaults[:middlewares].delete(VCR::Middleware::Excon)
+      ::Excon.defaults[:middlewares].delete(VCR::Middleware::Excon::Request)
+      ::Excon.defaults[:middlewares].delete(VCR::Middleware::Excon::Response)
     end
   end
 

data/spec/spec_helper.rb

@@ -54,7 +54,6 @@ end
 RSpec.configure do |config|
   config.order = :rand
   config.color_enabled = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
 
   config.expect_with :rspec do |expectations|
     expectations.syntax = :expect
@@ -65,7 +64,7 @@ RSpec.configure do |config|
   end
 
   tmp_dir = File.expand_path('../../tmp/cassette_library_dir', __FILE__)
-  config.before(:each) do
+  config.before(:each) do |example|
     unless example.metadata[:skip_vcr_reset]
       VCR.reset!
       VCR.configuration.cassette_library_dir = tmp_dir

data/spec/support/shared_example_groups/excon.rb

@@ -1,17 +1,19 @@
 shared_examples "Excon streaming" do
   context "when Excon's streaming API is used" do
+    def make_request_to(path)
+      chunks = []
+
+      Excon.get "http://localhost:#{VCR::SinatraApp.port}#{path}", :response_block => lambda { |chunk, remaining_bytes, total_bytes|
+        chunks << chunk
+      }
+
+      chunks.join
+    end
+
     it 'properly records and plays back the response' do
       allow(VCR).to receive(:real_http_connections_allowed?).and_return(true)
       recorded, played_back = [1, 2].map do
-        chunks = []
-
-        VCR.use_cassette('excon_streaming', :record => :once) do
-          Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo", :response_block => lambda { |chunk, remaining_bytes, total_bytes|
-            chunks << chunk
-          }
-        end
-
-        chunks.join
+        make_request_to('/foo')
       end
 
       expect(recorded).to eq(played_back)
@@ -39,6 +41,23 @@ shared_examples "Excon streaming" do
       expect(recorded).to eq(played_back)
       expect(recorded).to eq('404 not 200')
     end
+
+    context "when a cassette is played back and appended to" do
+      it 'does not allow Excon to mutate the response body in the cassette' do
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+          expect(make_request_to('/foo')).to eq('FOO!') # so it will save to disk again
+        end
+
+        VCR.use_cassette('excon_streaming', :record => :new_episodes) do
+          expect(make_request_to('/')).to eq('GET to root')
+        end
+      end
+    end
   end
 end
 

data/spec/support/shared_example_groups/request_hooks.rb

@@ -36,7 +36,7 @@ shared_examples_for "request hooks" do |library_hook_name, request_type|
       VCR.configuration.send(hook) { |r| hook_called = true }
 
       make_request(:disabled)
-      expect(hook_called).to be_false
+      expect(hook_called).to be false
     end
 
     specify "the #type of the yielded request given to the #{hook} hook is #{request_type}" do

data/spec/vcr/cassette/persisters/file_system_spec.rb

@@ -26,13 +26,13 @@ module VCR
 
         describe "#[]=" do
           it 'writes the given file contents to the given file name' do
-            expect(File.exist?(FileSystem.storage_location + '/foo.txt')).to be_false
+            expect(File.exist?(FileSystem.storage_location + '/foo.txt')).to be false
             FileSystem["foo.txt"] = "bar"
             expect(File.read(FileSystem.storage_location + '/foo.txt')).to eq("bar")
           end
 
           it 'creates any needed intermediary directories' do
-            expect(File.exist?(FileSystem.storage_location + '/a')).to be_false
+            expect(File.exist?(FileSystem.storage_location + '/a')).to be false
             FileSystem["a/b"] = "bar"
             expect(File.read(FileSystem.storage_location + '/a/b')).to eq("bar")
           end

data/spec/vcr/cassette_spec.rb

@@ -104,14 +104,14 @@ describe VCR::Cassette do
       it 'returns false when there is an existing cassette file with content' do
         cassette = VCR::Cassette.new("example", :record => :once)
         expect(File).to exist(cassette.file)
-        expect(File.size?(cassette.file)).to be_true
+        expect(File.size?(cassette.file)).to be_truthy
         expect(cassette).not_to be_recording
       end
 
       it 'returns true when there is an empty existing cassette file' do
         cassette = VCR::Cassette.new("empty", :record => :once)
         expect(File).to exist(cassette.file)
-        expect(File.size?(cassette.file)).to be_false
+        expect(File.size?(cassette.file)).to be_falsey
         expect(cassette).to be_recording
       end
 
@@ -313,7 +313,7 @@ describe VCR::Cassette do
           VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
           cassette = VCR::Cassette.new('example', :record => record_mode)
 
-          expect(cassette).to have(3).previously_recorded_interactions
+          expect(cassette.send(:previously_recorded_interactions).size).to eq(3)
 
           i1, i2, i3 = *cassette.send(:previously_recorded_interactions)
 
@@ -363,7 +363,7 @@ describe VCR::Cassette do
             ).exactly(3).times
 
             cassette = VCR::Cassette.new('example', :record => record_mode)
-            expect(cassette).to have(3).previously_recorded_interactions
+            expect(cassette.send(:previously_recorded_interactions).size).to eq(3)
           end
 
           it 'does not playback any interactions that are ignored in a before_playback hook' do
@@ -373,20 +373,20 @@ describe VCR::Cassette do
 
             VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
             cassette = VCR::Cassette.new('example', :record => record_mode)
-            expect(cassette).to have(2).previously_recorded_interactions
+            expect(cassette.send(:previously_recorded_interactions).size).to eq(2)
           end
 
           it 'instantiates the http_interactions with the loaded interactions and the request matchers' do
             VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
             cassette = VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
-            expect(cassette.http_interactions.interactions).to have(3).interactions
+            expect(cassette.http_interactions.interactions.size).to eq(3)
             expect(cassette.http_interactions.request_matchers).to eq([:body, :headers])
           end
         else
           it 'instantiates the http_interactions with the no interactions and the request matchers' do
             VCR.configuration.cassette_library_dir = "#{VCR::SPEC_ROOT}/fixtures/cassette_spec"
             cassette = VCR::Cassette.new('example', :record => record_mode, :match_requests_on => [:body, :headers])
-            expect(cassette.http_interactions.interactions).to have(0).interactions
+            expect(cassette.http_interactions.interactions.size).to eq(0)
             expect(cassette.http_interactions.request_matchers).to eq([:body, :headers])
           end
         end