vcr 1.11.3 → 2.0.0.beta1

data/lib/vcr/library_hooks/faraday.rb

@@ -0,0 +1,3 @@
+Kernel.warn "WARNING: `VCR.config { |c| c.stub_with :faraday }` is deprecated. " +
+            "Just use `VCR::Middleware::Faraday` in your faraday stack."
+

data/lib/vcr/library_hooks/typhoeus.rb

@@ -0,0 +1,98 @@
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+require 'typhoeus'
+
+VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.2.1', '0.2').check_version!
+
+module VCR
+  class LibraryHooks
+    module Typhoeus
+      module Helpers
+        def vcr_request_from(request)
+          VCR::Request.new \
+            request.method,
+            request.url,
+            request.body,
+            request.headers
+        end
+
+        def vcr_response_from(response)
+          VCR::Response.new \
+            VCR::ResponseStatus.new(response.code, response.status_message),
+            response.headers_hash,
+            response.body,
+            response.http_version
+        end
+      end
+
+      class RequestHandler < ::VCR::RequestHandler
+        include Helpers
+
+        attr_reader :request
+        def initialize(request)
+          @request = request
+        end
+
+      private
+
+        def on_stubbed_request
+          hydra_mock
+        end
+
+        def vcr_request
+          @vcr_request ||= vcr_request_from(request)
+        end
+
+        def typhoeus_response
+          @typhoeus_response ||= ::Typhoeus::Response.new \
+            :http_version   => stubbed_response.http_version,
+            :code           => stubbed_response.status.code,
+            :status_message => stubbed_response.status.message,
+            :headers_hash   => stubbed_response_headers,
+            :body           => stubbed_response.body
+        end
+
+        def hydra_mock
+          @hydra_mock ||= ::Typhoeus::HydraMock.new(/.*/, :any).tap do |m|
+            m.and_return(typhoeus_response)
+          end
+        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
+
+      extend Helpers
+      ::Typhoeus::Hydra.after_request_before_on_complete do |request|
+        unless VCR.library_hooks.disabled?(:typhoeus) || request.response.mock?
+          http_interaction = VCR::HTTPInteraction.new(vcr_request_from(request), vcr_response_from(request.response))
+          VCR.record_http_interaction(http_interaction)
+        end
+      end
+
+    end
+  end
+end
+
+# TODO: add Typhoeus::Hydra.register_stub_finder API to Typhoeus
+#       so we can use that instead of monkey-patching it.
+Typhoeus::Hydra::Stubbing::SharedMethods.class_eval do
+  undef find_stub_from_request
+  def find_stub_from_request(request)
+    VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
+  end
+end
+
+VCR.configuration.after_library_hooks_loaded do
+  # ensure WebMock's Typhoeus adapter does not conflict with us here
+  # (i.e. to double record requests or whatever).
+  if defined?(WebMock::HttpLibAdapters::TyphoeusAdapter)
+    WebMock::HttpLibAdapters::TyphoeusAdapter.disable!
+  end
+end
+

data/lib/vcr/library_hooks/webmock.rb

@@ -0,0 +1,100 @@
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+require 'webmock'
+
+VCR::VersionChecker.new('WebMock', WebMock.version, '1.7.0', '1.7').check_version!
+
+module VCR
+  class LibraryHooks
+    module WebMock
+      module Helpers
+        def response_hash_for(response)
+          {
+            :body    => response.body,
+            :status  => [response.status.code.to_i, response.status.message],
+            :headers => response.headers
+          }
+        end
+
+        def vcr_request_from(webmock_request)
+          VCR::Request.new \
+            webmock_request.method,
+            webmock_request.uri.to_s,
+            webmock_request.body,
+            webmock_request.headers
+        end
+
+        def vcr_response_from(response)
+          VCR::Response.new \
+            VCR::ResponseStatus.new(response.status.first, response.status.last),
+            response.headers,
+            response.body,
+            '1.1'
+        end
+      end
+
+      class RequestHandler < ::VCR::RequestHandler
+        include Helpers
+
+        attr_reader :request
+        def initialize(request)
+          @request = request
+        end
+
+      private
+
+        def stubbed_response
+          VCR.http_interactions.has_interaction_matching?(vcr_request)
+        end
+
+        def vcr_request
+          @vcr_request ||= vcr_request_from(request)
+        end
+
+        def on_ignored_request;    false; end
+        def on_stubbed_request;    true;  end
+        def on_recordable_request; false; end
+      end
+
+      extend Helpers
+
+      GLOBAL_VCR_HOOK = ::WebMock::RequestStub.new(:any, /.*/).tap do |stub|
+        stub.with { |request|
+          RequestHandler.new(request).handle
+        }.to_return(lambda { |request|
+          response_hash_for VCR.http_interactions.response_for(vcr_request_from(request))
+        })
+      end
+
+      ::WebMock::StubRegistry.instance.register_request_stub(GLOBAL_VCR_HOOK)
+
+      ::WebMock.after_request(:real_requests_only => true) do |request, response|
+        unless VCR.library_hooks.disabled?(:webmock)
+          http_interaction = VCR::HTTPInteraction.new \
+            vcr_request_from(request),
+            vcr_response_from(response)
+
+          VCR.record_http_interaction(http_interaction)
+        end
+      end
+    end
+  end
+end
+
+class << WebMock
+  # ensure HTTP requests are always allowed; VCR takes care of disallowing
+  # them at the appropriate times in its hook
+  undef net_connect_allowed?
+  def net_connect_allowed?(*args)
+    true
+  end
+end
+
+WebMock::StubRegistry.class_eval do
+  # ensure our VCR hook is not removed when WebMock is reset
+  undef reset!
+  def reset!
+    self.request_stubs = [VCR::LibraryHooks::WebMock::GLOBAL_VCR_HOOK]
+  end
+end
+

data/lib/vcr/middleware/faraday.rb

@@ -1,55 +1,41 @@
 require 'faraday'
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+
+VCR::VersionChecker.new('Faraday', Faraday::VERSION, '0.7.0', '0.7').check_version!
 
 module VCR
   module Middleware
-    class Faraday < ::Faraday::Middleware
-      include Common
+    class Faraday
+      include VCR::Deprecations::Middleware::Faraday
 
-      class HttpConnectionNotAllowedError < StandardError; end
+      def initialize(app)
+        super
+        @app = app
+      end
 
       def call(env)
-        VCR::HttpStubbingAdapters::Faraday.exclusively_enabled do
-          VCR.use_cassette(*cassette_arguments(env)) do |cassette|
-            request = request_for(env)
-
-            if VCR::HttpStubbingAdapters::Faraday.uri_should_be_ignored?(request.uri)
-              @app.call(env)
-            elsif response = VCR::HttpStubbingAdapters::Faraday.stubbed_response_for(request)
-              headers = env[:response_headers] ||= ::Faraday::Utils::Headers.new
-              headers.update response.headers if response.headers
-              env.update :status => response.status.code, :body => response.body
-
-              faraday_response = ::Faraday::Response.new
-              faraday_response.finish(env) unless env[:parallel_manager]
-              env[:response] = faraday_response
-            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
+        # Faraday must be exlusive here in case another library hook is being used.
+        # We don't want double recording/double playback.
+        VCR.library_hooks.exclusively_enabled(:faraday) do
+          RequestHandler.new(@app, env).handle
         end
       end
 
+      class RequestHandler < ::VCR::RequestHandler
+        attr_reader :app, :env
+        def initialize(app, env)
+          @app, @env = app, env
+        end
+
       private
 
-        def request_for(env)
-          VCR::Request.new(
+        def vcr_request
+          @vcr_request ||= VCR::Request.new \
             env[:method],
             env[:url].to_s,
             env[:body],
             env[:request_headers]
-          )
         end
 
         def response_for(env)
@@ -62,6 +48,27 @@ module VCR
             '1.1'
           )
         end
+
+        def on_ignored_request
+          app.call(env)
+        end
+
+        def on_stubbed_request
+          headers = env[:response_headers] ||= ::Faraday::Utils::Headers.new
+          headers.update stubbed_response.headers if stubbed_response.headers
+          env.update :status => stubbed_response.status.code, :body => stubbed_response.body
+
+          faraday_response = ::Faraday::Response.new
+          faraday_response.finish(env) unless env[:parallel_manager]
+          env[:response] = faraday_response
+        end
+
+        def on_recordable_request
+          app.call(env).on_complete do |env|
+            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, response_for(env)))
+          end
+        end
+      end
     end
   end
 end

data/lib/vcr/middleware/rack.rb

@@ -1,11 +1,27 @@
 module VCR
   module Middleware
+    class CassetteArguments
+      def initialize
+        @name    = nil
+        @options = {}
+      end
+
+      def name(name = nil)
+        @name = name if name
+        @name
+      end
+
+      def options(options = {})
+        @options.merge!(options)
+      end
+    end
+
     class Rack
-      include Common
+      include VCR::VariableArgsBlockCaller
 
-      def initialize(*args)
-        @mutex = Mutex.new
-        super
+      def initialize(app, &block)
+        raise ArgumentError.new("You must provide a block to set the cassette options") unless block
+        @app, @cassette_arguments_block, @mutex = app, block, Mutex.new
       end
 
       def call(env)
@@ -15,6 +31,14 @@ module VCR
           end
         end
       end
+
+    private
+
+      def cassette_arguments(env)
+        arguments = CassetteArguments.new
+        call_block(@cassette_arguments_block, arguments, env)
+        [arguments.name, arguments.options]
+      end
     end
   end
 end

data/lib/vcr/request_handler.rb

@@ -0,0 +1,43 @@
+module VCR
+  class RequestHandler
+    def handle
+      return on_ignored_request    if should_ignore?
+      return on_stubbed_request    if stubbed_response
+      return on_recordable_request if VCR.real_http_connections_allowed?
+      on_connection_not_allowed
+    end
+
+  private
+
+    def should_ignore?
+      disabled? || VCR.request_ignorer.ignore?(vcr_request)
+    end
+
+    def disabled?
+      VCR.library_hooks.disabled?(library_name)
+    end
+
+    def stubbed_response
+      @stubbed_response ||= VCR.http_interactions.response_for(vcr_request)
+    end
+
+    def library_name
+      # extracts `:typhoeus` from `VCR::LibraryHooks::Typhoeus::RequestHandler`
+      @library_name ||= self.class.name.split('::')[-2].downcase.to_sym
+    end
+
+    # Subclasses can implement these
+    def on_ignored_request
+    end
+
+    def on_stubbed_request
+    end
+
+    def on_recordable_request
+    end
+
+    def on_connection_not_allowed
+      raise VCR::HTTPConnectionNotAllowedError.new(vcr_request)
+    end
+  end
+end

data/lib/vcr/request_ignorer.rb

@@ -0,0 +1,31 @@
+require 'uri'
+require 'set'
+
+module VCR
+  class RequestIgnorer
+    LOCALHOST_ALIASES = %w( localhost 127.0.0.1 0.0.0.0 )
+
+    def ignore_localhost=(value)
+      if value
+        ignore_hosts(*LOCALHOST_ALIASES)
+      else
+        ignored_hosts.reject! { |h| LOCALHOST_ALIASES.include?(h) }
+      end
+    end
+
+    def ignore_hosts(*hosts)
+      ignored_hosts.merge(hosts)
+    end
+
+    def ignore?(request)
+      ignored_hosts.include?(URI(request.uri).host)
+    end
+
+  private
+
+    def ignored_hosts
+      @ignored_hosts ||= Set.new
+    end
+  end
+end
+

data/lib/vcr/request_matcher_registry.rb

@@ -0,0 +1,86 @@
+module VCR
+  class RequestMatcherRegistry
+    DEFAULT_MATCHERS = [:method, :uri]
+
+    class Matcher < Struct.new(:callable)
+      def matches?(request_1, request_2)
+        callable.call(request_1, request_2)
+      end
+    end
+
+    def initialize
+      @registry = {}
+      register_built_ins
+    end
+
+    def register(name, &block)
+      if @registry.has_key?(name)
+        warn "WARNING: There is already a VCR request matcher registered for #{name.inspect}. Overriding it."
+      end
+
+      @registry[name] = Matcher.new(block)
+    end
+
+    def [](matcher)
+      @registry.fetch(matcher) do
+        matcher.respond_to?(:call) ?
+          Matcher.new(matcher) :
+          raise_unregistered_matcher_error(matcher)
+      end
+    end
+
+    def uri_without_params(*ignores)
+      ignores = ignores.map { |i| i.to_s }
+
+      lambda do |request_1, request_2|
+        uri_1, uri_2 = [request_1, request_2].map do |r|
+          URI(r.uri).tap do |uri|
+            uri.query = uri.query.split('&').tap { |params|
+              params.map! do |p|
+                key, value = p.split('=')
+                key.gsub!(/\[\]\z/, '') # handle params like tag[]=
+                [key, value]
+              end
+
+              params.reject! { |p| ignores.include?(p.first) }
+              params.map!    { |p| p.join('=') }
+            }.join('&')
+          end
+        end
+
+        uri_1 == uri_2
+      end
+    end
+    alias uri_without_param uri_without_params
+
+  private
+
+    def raise_unregistered_matcher_error(name)
+      raise Errors::UnregisteredMatcherError.new \
+        "There is no matcher registered for #{name.inspect}. " +
+        "Did you mean one of #{@registry.keys.map(&:inspect).join(', ')}?"
+    end
+
+    def register_built_ins
+      register(:method)  { |r1, r2| r1.method == r2.method }
+      register(:uri)     { |r1, r2| normalize_uri(r1.uri) == normalize_uri(r2.uri) }
+      register(:host)    { |r1, r2| URI(r1.uri).host == URI(r2.uri).host }
+      register(:path)    { |r1, r2| URI(r1.uri).path == URI(r2.uri).path }
+      register(:body)    { |r1, r2| r1.body == r2.body }
+      register(:headers) { |r1, r2| r1.headers == r2.headers }
+    end
+
+    def normalize_uri(uri)
+      # TODO: find a better, less-hacky way to do this.
+      if defined?(::WebMock)
+        ::WebMock::Util::URI.normalize_uri(uri).to_s
+      elsif defined?(VCR::Middleware::Faraday)
+        # Faraday normalizes URIs by replacing '+' with '%20'
+        uri.gsub('+', '%20')
+      else
+        uri
+      end
+    end
+  end
+end
+