vcr 1.3.3 → 1.4.0

data/lib/vcr/config.rb

@@ -25,12 +25,21 @@ module VCR
       end
 
       def ignore_localhost=(value)
-        VCR.http_stubbing_adapter && VCR.http_stubbing_adapter.ignore_localhost = value
         @ignore_localhost = value
+        VCR.http_stubbing_adapter.ignore_localhost = value if http_stubbing_libraries.any?
       end
 
       def ignore_localhost?
-        VCR.http_stubbing_adapter ? VCR.http_stubbing_adapter.ignore_localhost? : @ignore_localhost
+        @ignore_localhost
+      end
+
+      def allow_http_connections_when_no_cassette=(value)
+        @allow_http_connections_when_no_cassette = value
+        VCR.http_stubbing_adapter.set_http_connections_allowed_to_default if http_stubbing_libraries.any?
+      end
+
+      def allow_http_connections_when_no_cassette?
+        !!@allow_http_connections_when_no_cassette
       end
     end
   end

data/lib/vcr/extensions/net_http.rb

@@ -4,6 +4,10 @@ require 'vcr/extensions/net_http_response'
 module Net
   class HTTP
     def request_with_vcr(request, body = nil, &block)
+      unless VCR::HttpStubbingAdapters::FakeWeb.enabled?
+        return request_without_vcr(request, body, &block)
+      end
+
       vcr_request = VCR::Request.from_net_http_request(self, request)
       response = request_without_vcr(request, body)
 

data/lib/vcr/http_stubbing_adapters/common.rb

@@ -1,6 +1,7 @@
 module VCR
   module HttpStubbingAdapters
     autoload :FakeWeb,          'vcr/http_stubbing_adapters/fakeweb'
+    autoload :Faraday,          'vcr/http_stubbing_adapters/faraday'
     autoload :MultiObjectProxy, 'vcr/http_stubbing_adapters/multi_object_proxy'
     autoload :Typhoeus,         'vcr/http_stubbing_adapters/typhoeus'
     autoload :WebMock,          'vcr/http_stubbing_adapters/webmock'
@@ -8,17 +9,43 @@ module VCR
     class UnsupportedRequestMatchAttributeError < ArgumentError; end
 
     module Common
-      def self.add_vcr_info_to_exception_message(exception_klass)
-        exception_klass.class_eval do
-          def initialize(message)
-            super(message + '.  ' + VCR::HttpStubbingAdapters::Common::RECORDING_INSTRUCTIONS)
+      class << self
+        attr_accessor :exclusively_enabled_adapter
+
+        def add_vcr_info_to_exception_message(exception_klass)
+          exception_klass.class_eval do
+            def initialize(message)
+              super(message + '.  ' + VCR::HttpStubbingAdapters::Common::RECORDING_INSTRUCTIONS)
+            end
           end
         end
+
+        def adapters
+          @adapters ||= []
+        end
+
+        def included(adapter)
+          adapters << adapter
+        end
       end
 
       RECORDING_INSTRUCTIONS = "You can use VCR to automatically record this request and replay it later.  " +
                                "For more details, visit the VCR wiki at: http://github.com/myronmarston/vcr/wiki"
 
+      def enabled?
+        [nil, self].include? VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter
+      end
+
+      def exclusively_enabled
+        VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter = self
+
+        begin
+          yield
+        ensure
+          VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter = nil
+        end
+      end
+
       def check_version!
         version_too_low, version_too_high = compare_version
 
@@ -33,6 +60,10 @@ module VCR
         @library_name ||= self.to_s.split('::').last
       end
 
+      def set_http_connections_allowed_to_default
+        self.http_connections_allowed = VCR::Config.allow_http_connections_when_no_cassette?
+      end
+
       private
 
       def compare_version

data/lib/vcr/http_stubbing_adapters/faraday.rb

@@ -0,0 +1,80 @@
+require 'faraday'
+
+module VCR
+  module HttpStubbingAdapters
+    module Faraday
+      include Common
+      extend self
+
+      MINIMUM_VERSION = '0.5.3'
+      MAXIMUM_VERSION = '0.5'
+
+      attr_writer :http_connections_allowed, :ignore_localhost
+
+      def http_connections_allowed?
+        !!@http_connections_allowed
+      end
+
+      def ignore_localhost?
+        !!@ignore_localhost
+      end
+
+      def stub_requests(http_interactions, match_attributes)
+        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
+          queue = stub_queues[request_matcher]
+          responses.each { |res| queue << res }
+        end
+      end
+
+      def create_stubs_checkpoint(checkpoint_name)
+        checkpoints[checkpoint_name] = stub_queue_dup
+      end
+
+      def restore_stubs_checkpoint(checkpoint_name)
+        @stub_queues = checkpoints.delete(checkpoint_name)
+      end
+
+      def stubbed_response_for(request_matcher)
+        queue = stub_queues[request_matcher]
+        return queue.shift if queue.size > 1
+        queue.first
+      end
+
+      def reset!
+        instance_variables.each do |ivar|
+          remove_instance_variable(ivar)
+        end
+      end
+
+      private
+
+        def version
+          ::Faraday::VERSION
+        end
+
+        def checkpoints
+          @checkpoints ||= {}
+        end
+
+        def stub_queues
+          @stub_queues ||= hash_of_arrays
+        end
+
+        def stub_queue_dup
+          dup = hash_of_arrays
+
+          stub_queues.each do |k, v|
+            dup[k] = v.dup
+          end
+
+          dup
+        end
+
+        def hash_of_arrays
+          Hash.new { |h, k| h[k] = [] }
+        end
+    end
+  end
+end
+
+VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(VCR::Middleware::Faraday::HttpConnectionNotAllowedError)

data/lib/vcr/http_stubbing_adapters/typhoeus.rb

@@ -74,7 +74,7 @@ module VCR
 end
 
 Typhoeus::Hydra.after_request_before_on_complete do |request|
-  unless request.response.mock?
+  if VCR::HttpStubbingAdapters::Typhoeus.enabled? && !request.response.mock?
     http_interaction = VCR::HTTPInteraction.new(
       VCR::Request.new(
         request.method,

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -73,25 +73,27 @@ module VCR
 end
 
 WebMock.after_request(:real_requests_only => true) do |request, response|
-  http_interaction = VCR::HTTPInteraction.new(
-    VCR::Request.new(
-      request.method,
-      request.uri.to_s,
-      request.body,
-      request.headers
-    ),
-    VCR::Response.new(
-      VCR::ResponseStatus.new(
-        response.status.first,
-        response.status.last
+  if VCR::HttpStubbingAdapters::WebMock.enabled?
+    http_interaction = VCR::HTTPInteraction.new(
+      VCR::Request.new(
+        request.method,
+        request.uri.to_s,
+        request.body,
+        request.headers
       ),
-      response.headers,
-      response.body,
-      '1.1'
+      VCR::Response.new(
+        VCR::ResponseStatus.new(
+          response.status.first,
+          response.status.last
+        ),
+        response.headers,
+        response.body,
+        '1.1'
+      )
     )
-  )
 
-  VCR.record_http_interaction(http_interaction)
+    VCR.record_http_interaction(http_interaction)
+  end
 end
 
 WebMock::NetConnectNotAllowedError.class_eval do

data/lib/vcr/middleware/cassette_arguments.rb

@@ -0,0 +1,18 @@
+module VCR
+  module Middleware
+    class CassetteArguments
+      def initialize
+        @options = {}
+      end
+
+      def name(name = nil)
+        @name = name if name
+        @name
+      end
+
+      def options(options = {})
+        @options.merge!(options)
+      end
+    end
+  end
+end

data/lib/vcr/middleware/common.rb

@@ -0,0 +1,22 @@
+module VCR
+  module Middleware
+    module Common
+      def initialize(app, &block)
+        raise ArgumentError.new("You must provide a block to set the cassette options") unless block
+        @app, @cassette_arguments_block = app, block
+      end
+
+      private
+
+        def cassette_arguments(env)
+          arguments = CassetteArguments.new
+
+          block_args = [arguments]
+          block_args << env unless @cassette_arguments_block.arity == 1
+
+          @cassette_arguments_block.call(*block_args)
+          [arguments.name, arguments.options]
+        end
+    end
+  end
+end

data/lib/vcr/middleware/faraday.rb

@@ -0,0 +1,79 @@
+require 'faraday'
+
+module VCR
+  module Middleware
+    class Faraday < ::Faraday::Middleware
+      include Common
+
+      class HttpConnectionNotAllowedError < StandardError; end
+
+      def call(env)
+        VCR::HttpStubbingAdapters::Faraday.exclusively_enabled do
+          VCR.use_cassette(*cassette_arguments(env)) do |cassette|
+            request = request_for(env)
+            request_matcher = request.matcher(cassette.match_requests_on)
+
+            if VCR::HttpStubbingAdapters::Faraday.ignore_localhost? && VCR::LOCALHOST_ALIASES.include?(URI.parse(request.uri).host)
+              @app.call(env)
+            elsif response = VCR::HttpStubbingAdapters::Faraday.stubbed_response_for(request_matcher)
+              env.update(
+                :status           => response.status.code,
+                :response_headers => correctly_cased_headers(response.headers),
+                :body             => response.body
+              )
+
+              env[:response].finish(env)
+            elsif VCR::HttpStubbingAdapters::Faraday.http_connections_allowed?
+              response = @app.call(env)
+
+              # Checking #enabled? isn't strictly needed, but conforms
+              # the Faraday adapter to the behavior of the other adapters
+              if VCR::HttpStubbingAdapters::Faraday.enabled?
+                VCR.record_http_interaction(VCR::HTTPInteraction.new(request, response_for(env)))
+              end
+
+              response
+            else
+              raise HttpConnectionNotAllowedError.new(
+                "Real HTTP connections are disabled. Request: #{request.method.inspect} #{request.uri}"
+              )
+            end
+          end
+        end
+      end
+
+      private
+
+        def request_for(env)
+          VCR::Request.new(
+            env[:method],
+            env[:url].to_s,
+            env[:body],
+            env[:request_headers]
+          )
+        end
+
+        def response_for(env)
+          response = env[:response]
+
+          VCR::Response.new(
+            VCR::ResponseStatus.new(response.status, nil),
+            response.headers,
+            response.body,
+            '1.1'
+          )
+        end
+
+        def correctly_cased_headers(headers)
+          correctly_cased_hash = {}
+
+          headers.each do |key, value|
+            key = key.to_s.split('-').map { |segment| segment.capitalize }.join("-")
+            correctly_cased_hash[key] = value
+          end
+
+          correctly_cased_hash
+        end
+    end
+  end
+end

data/lib/vcr/middleware/rack.rb

@@ -0,0 +1,13 @@
+module VCR
+  module Middleware
+    class Rack
+      include Common
+
+      def call(env)
+        VCR.use_cassette(*cassette_arguments(env)) do
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vcr/request_matcher.rb

@@ -69,7 +69,22 @@ module VCR
       # on Ruby 1.8.6, identical sets have different hash values,
       # but identical arrays have the same hash values,
       # so we convert match_attributes to an array here.
-      [match_attributes.to_a, method, uri, headers, body].hash
+      [match_attributes.to_a, method, uri, sorted_header_array, body].hash
     end
+
+    private
+
+      def sorted_header_array
+        header_hash = headers
+        return header_hash unless header_hash.is_a?(Hash)
+
+        array = []
+        header_hash.each do |k, v|
+          v = v.sort if v.respond_to?(:sort)
+          array << [k, v]
+        end
+
+        array.sort! { |a1, a2| a1.first <=> a2.first }
+      end
   end
 end

data/lib/vcr/version.rb

@@ -3,7 +3,7 @@ module VCR
 
   def version
     @version ||= begin
-      string = '1.3.3'
+      string = '1.4.0'
 
       def string.parts; VCR.version.split('.').map { |p| p.to_i }; end
       def string.major; parts[0]; end

data/spec/config_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe VCR::Config do
+  def stub_no_http_stubbing_adapter
+    VCR.stub(:http_stubbing_adapter).and_raise(ArgumentError)
+    VCR::Config.stub(:http_stubbing_libraries).and_return([])
+  end
+
   describe '#cassette_library_dir=' do
     temp_dir(File.expand_path(File.dirname(__FILE__) + '/fixtures/config_spec'))
 
@@ -52,12 +57,32 @@ describe VCR::Config do
       end
     end
 
-    it 'stores the value even when VCR.http_stubbing_adapter is nil' do
-      VCR.stub!(:http_stubbing_adapter).and_return(nil)
+    it 'stores the value even when VCR.http_stubbing_adapter is not set' do
+      stub_no_http_stubbing_adapter
       [true, false].each do |val|
         VCR::Config.ignore_localhost = val
         VCR::Config.ignore_localhost?.should == val
       end
     end
   end
+
+  describe '#allow_http_connections_when_no_cassette=' do
+    [true, false].each do |val|
+      it "sets the allow_http_connections_when_no_cassette to #{val} when set to #{val}" do
+        VCR::Config.allow_http_connections_when_no_cassette = val
+        VCR::Config.allow_http_connections_when_no_cassette?.should == val
+      end
+    end
+
+    it 'sets http_connnections_allowed to the default' do
+      VCR.http_stubbing_adapter.should respond_to(:set_http_connections_allowed_to_default)
+      VCR.http_stubbing_adapter.should_receive(:set_http_connections_allowed_to_default)
+      VCR::Config.allow_http_connections_when_no_cassette = true
+    end
+
+    it "works when the adapter hasn't been set yet" do
+      stub_no_http_stubbing_adapter
+      VCR::Config.allow_http_connections_when_no_cassette = true
+    end
+  end
 end