vcr 1.11.3 → 2.0.0.beta1

data/lib/vcr/cassette/reader.rb

@@ -1,7 +1,5 @@
 module VCR
   class Cassette
-    class MissingERBVariableError < NameError; end
-
     class Reader
       def initialize(file_name, erb)
         @file_name, @erb = file_name, erb
@@ -15,44 +13,44 @@ module VCR
         handle_name_error(e)
       end
 
-      private
+    private
 
-        def handle_name_error(e)
-          example_hash = (erb_variables || {}).merge(e.name => 'some value')
+      def handle_name_error(e)
+        example_hash = (erb_variables || {}).merge(e.name => 'some value')
 
-          raise MissingERBVariableError.new(
-            "The ERB in the #{@file_name} cassette file references undefined variable #{e.name}.  " +
-            "Pass it to the cassette using :erb => #{ example_hash.inspect }."
-          )
-        end
+        raise Errors::MissingERBVariableError.new(
+          "The ERB in the #{@file_name} cassette file references undefined variable #{e.name}.  " +
+          "Pass it to the cassette using :erb => #{ example_hash.inspect }."
+        )
+      end
 
-        def use_erb?
-          !!@erb
-        end
+      def use_erb?
+        !!@erb
+      end
 
-        def erb_variables
-          @erb if @erb.is_a?(Hash)
-        end
+      def erb_variables
+        @erb if @erb.is_a?(Hash)
+      end
 
-        def file_content
-          @file_content ||= File.read(@file_name)
-        end
+      def file_content
+        @file_content ||= File.read(@file_name)
+      end
 
-        def template
-          @template ||= ERB.new(file_content)
-        end
+      def template
+        @template ||= ERB.new(file_content)
+      end
 
-        @@struct_cache = Hash.new do |hash, attributes|
-          hash[attributes] = Struct.new(*attributes)
-        end
+      @@struct_cache = Hash.new do |hash, attributes|
+        hash[attributes] = Struct.new(*attributes)
+      end
 
-        def variables_object
-          @variables_object ||= @@struct_cache[erb_variables.keys].new(*erb_variables.values)
-        end
+      def variables_object
+        @variables_object ||= @@struct_cache[erb_variables.keys].new(*erb_variables.values)
+      end
 
-        def binding_for_variables
-          @binding_for_variables ||= variables_object.instance_eval { binding }
-        end
+      def binding_for_variables
+        @binding_for_variables ||= variables_object.instance_eval { binding }
+      end
     end
   end
 end

data/lib/vcr/configuration.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'vcr/util/hooks'
+
+module VCR
+  class Configuration
+    include VCR::Hooks
+    include VCR::VariableArgsBlockCaller
+
+    define_hook :before_record
+    define_hook :before_playback
+    define_hook :after_library_hooks_loaded
+
+    def initialize
+      @allow_http_connections_when_no_cassette = nil
+      @default_cassette_options = {
+        :record            => :once,
+        :match_requests_on => RequestMatcherRegistry::DEFAULT_MATCHERS
+      }
+    end
+
+    attr_reader :cassette_library_dir
+    def cassette_library_dir=(cassette_library_dir)
+      @cassette_library_dir = cassette_library_dir
+      FileUtils.mkdir_p(cassette_library_dir) if cassette_library_dir
+    end
+
+    attr_reader :default_cassette_options
+    def default_cassette_options=(overrides)
+      @default_cassette_options.merge!(overrides)
+    end
+
+    def hook_into(*hooks)
+      hooks.each { |a| load_library_hook(a) }
+      invoke_hook(:after_library_hooks_loaded)
+    end
+
+    def register_request_matcher(name, &block)
+      VCR.request_matchers.register(name, &block)
+    end
+
+    def ignore_hosts(*hosts)
+      VCR.request_ignorer.ignore_hosts(*hosts)
+    end
+    alias ignore_host ignore_hosts
+
+    def ignore_localhost=(value)
+      VCR.request_ignorer.ignore_localhost = value
+    end
+
+    attr_writer :allow_http_connections_when_no_cassette
+    def allow_http_connections_when_no_cassette?
+      !!@allow_http_connections_when_no_cassette
+    end
+
+    def filter_sensitive_data(placeholder, tag = nil, &block)
+      before_record(tag) do |interaction|
+        interaction.filter!(call_block(block, interaction), placeholder)
+      end
+
+      before_playback(tag) do |interaction|
+        interaction.filter!(placeholder, call_block(block, interaction))
+      end
+    end
+
+  private
+
+    def load_library_hook(hook)
+      file = "vcr/library_hooks/#{hook}"
+      require file
+    rescue LoadError => e
+      raise e unless e.message.include?(file) # in case FakeWeb/WebMock/etc itself is not available
+      raise ArgumentError.new("#{hook.inspect} is not a supported VCR HTTP library hook.")
+    end
+  end
+end
+

data/lib/vcr/deprecations.rb

@@ -0,0 +1,39 @@
+module VCR
+  def config
+    warn "WARNING: `VCR.config` is deprecated.  Use VCR.configure instead."
+    configure { |c| yield c }
+  end
+
+  def self.const_missing(const)
+    return super unless const == :Config
+    warn "WARNING: `VCR::Config` is deprecated.  Use VCR.configuration instead."
+    configuration
+  end
+
+  def Cassette.const_missing(const)
+    return super unless const == :MissingERBVariableError
+    warn "WARNING: `VCR::Cassette::MissingERBVariableError` is deprecated.  Use `VCR::Errors::MissingERBVariableError` instead."
+    Errors::MissingERBVariableError
+  end
+
+  class Configuration
+    def stub_with(*adapters)
+      warn "WARNING: `VCR.config { |c| c.stub_with ... }` is deprecated. Use `VCR.configure { |c| c.hook_into ... }` instead."
+      hook_into(*adapters)
+    end
+  end
+
+  module Deprecations
+    module Middleware
+      module Faraday
+        def initialize(*args)
+          if block_given?
+            Kernel.warn "WARNING: Passing a block to `VCR::Middleware::Faraday` is deprecated. \n" +
+                        "As of VCR 2.0, you need to wrap faraday requests in VCR.use_cassette, just like with any other library hook."
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vcr/errors.rb

@@ -0,0 +1,22 @@
+module VCR
+  module Errors
+    class Error                     < StandardError; end
+    class CassetteInUseError        < Error; end
+    class TurnedOffError            < Error; end
+    class MissingERBVariableError   < Error; end
+    class LibraryVersionTooLowError < Error; end
+    class UnregisteredMatcherError  < Error; end
+
+
+    class HTTPConnectionNotAllowedError < Error
+      def initialize(request)
+        super \
+          "Real HTTP connections are disabled. " +
+          "Request: #{request.method.to_s.upcase} #{request.uri}. " +
+          "You can use VCR to automatically record this request and replay it later. " +
+          "For more details, visit the VCR documentation at: http://relishapp.com/myronmarston/vcr/v/#{VCR.version.gsub('.', '-')}"
+      end
+    end
+  end
+end
+

data/lib/vcr/library_hooks.rb

@@ -0,0 +1,19 @@
+module VCR
+  class LibraryHooks
+    def initialize
+      @exclusive_hook = nil
+    end
+
+    def disabled?(hook)
+      ![nil, hook].include?(@exclusive_hook)
+    end
+
+    def exclusively_enabled(hook)
+      @exclusive_hook = hook
+      yield
+    ensure
+      @exclusive_hook = nil
+    end
+  end
+end
+

data/lib/vcr/library_hooks/excon.rb

@@ -0,0 +1,136 @@
+require 'vcr/util/version_checker'
+require 'vcr/request_handler'
+require 'excon'
+
+VCR::VersionChecker.new('Excon', Excon::VERSION, '0.6.5', '0.6').check_version!
+
+module VCR
+  class LibraryHooks
+    module Excon
+      class RequestHandler < ::VCR::RequestHandler
+        attr_reader :params
+        def initialize(params)
+          @params = params
+        end
+
+      private
+
+        def on_stubbed_request
+          {
+            :body     => stubbed_response.body,
+            :headers  => normalized_headers(stubbed_response.headers || {}),
+            :status   => stubbed_response.status.code
+          }
+        end
+
+        def response_from_excon_error(error)
+          if error.respond_to?(:response)
+            error.response
+          elsif error.respond_to?(:socket_error)
+            response_from_excon_error(error.socket_error)
+          else
+            warn "WARNING: VCR could not extract a response from Excon error (#{error.inspect})"
+          end
+        end
+
+        def perform_real_request
+          connection = ::Excon.new(uri)
+
+          response = begin
+            connection.request(params.merge(:mock => false))
+          rescue ::Excon::Errors::Error => e
+            yield response_from_excon_error(e) if block_given?
+            raise e
+          end
+
+          yield response if block_given?
+
+          response.attributes
+        end
+        alias on_ignored_request perform_real_request
+
+        def on_recordable_request
+          perform_real_request do |response|
+            http_interaction = http_interaction_for(response)
+            VCR.record_http_interaction(http_interaction)
+          end
+        end
+
+        def uri
+          @uri ||= "#{params[:scheme]}://#{params[:host]}:#{params[:port]}#{params[:path]}#{query}"
+        end
+
+        def query
+          @query ||= case params[:query]
+            when String
+              "?#{params[:query]}"
+            when Hash
+              qry = '?'
+              for key, values in params[:query]
+                if values.nil?
+                  qry << key.to_s << '&'
+                else
+                  for value in [*values]
+                    qry << key.to_s << '=' << CGI.escape(value.to_s) << '&'
+                  end
+                end
+              end
+              qry.chop! # remove trailing '&'
+            else
+              ''
+          end
+        end
+
+        def http_interaction_for(response)
+          VCR::HTTPInteraction.new \
+            vcr_request,
+            vcr_response(response)
+        end
+
+        def vcr_request
+          @vcr_request ||= begin
+            headers = params[:headers].dup
+            headers.delete("Host")
+
+            VCR::Request.new \
+              params[:method],
+              uri,
+              params[:body],
+              headers
+          end
+        end
+
+        def vcr_response(response)
+          VCR::Response.new \
+            VCR::ResponseStatus.new(response.status, nil),
+            response.headers,
+            response.body,
+            nil
+        end
+
+        def normalized_headers(headers)
+          normalized = {}
+          headers.each do |k, v|
+            v = v.join(', ') if v.respond_to?(:join)
+            normalized[normalize_header_key(k)] = v
+          end
+          normalized
+        end
+
+        def normalize_header_key(key)
+          key.split('-').               # 'user-agent' => %w(user agent)
+            each { |w| w.capitalize! }. # => %w(User Agent)
+            join('-')
+        end
+
+        ::Excon.stub({}) do |params|
+          self.new(params).handle
+        end
+      end
+
+    end
+  end
+end
+
+Excon.mock = true
+

data/lib/vcr/library_hooks/fakeweb.rb

@@ -0,0 +1,110 @@
+require 'vcr/util/version_checker'
+require 'fakeweb'
+require 'net/http'
+require 'vcr/extensions/net_http_response'
+require 'vcr/request_handler'
+
+VCR::VersionChecker.new('FakeWeb', FakeWeb::VERSION, '1.3.0', '1.3').check_version!
+
+module VCR
+  class LibraryHooks
+    module FakeWeb
+      class RequestHandler < ::VCR::RequestHandler
+        attr_reader :net_http, :request, :request_body, :block
+        def initialize(net_http, request, request_body = nil, &block)
+          @net_http, @request, @request_body, @block =
+           net_http,  request,  request_body,  block
+        end
+
+      private
+
+        def perform_and_record_request
+          # Net::HTTP calls #request recursively in certain circumstances.
+          # We only want to record hte request when the request is started, as
+          # that is the final time through #request.
+          return perform_request unless net_http.started?
+
+          perform_request do |response|
+            VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, vcr_response_from(response))
+            response.extend VCR::Net::HTTPResponse # "unwind" the response
+            block.call(response) if block
+          end
+        end
+        alias on_recordable_request perform_and_record_request
+
+        def perform_stubbed_request
+          with_exclusive_fakeweb_stub(stubbed_response) do
+            perform_request
+          end
+        end
+        alias on_stubbed_request perform_stubbed_request
+
+        def perform_request(&record_block)
+          net_http.request_without_vcr(request, request_body, &(record_block || block))
+        end
+        alias on_ignored_request perform_request
+
+        def uri
+          @uri ||= ::FakeWeb::Utility.request_uri_as_string(net_http, request)
+        end
+
+        def response_hash(response)
+          (response.headers || {}).merge(
+            :body   => response.body,
+            :status => [response.status.code.to_s, response.status.message]
+          )
+        end
+
+        def with_exclusive_fakeweb_stub(response)
+          original_map = ::FakeWeb::Registry.instance.uri_map.dup
+          ::FakeWeb.clean_registry
+          ::FakeWeb.register_uri(:any, /.*/, response_hash(response))
+
+          begin
+            return yield
+          ensure
+            ::FakeWeb::Registry.instance.uri_map = original_map
+          end
+        end
+
+        def vcr_request
+          @vcr_request ||= VCR::Request.new \
+            request.method.downcase.to_sym,
+            uri,
+            request_body,
+            request.to_hash
+        end
+
+        def vcr_response_from(response)
+          VCR::Response.new \
+            VCR::ResponseStatus.new(response.code.to_i, response.message),
+            response.to_hash,
+            response.body,
+            response.http_version
+        end
+      end
+    end
+  end
+end
+
+module Net
+  class HTTP
+    unless method_defined?(:request_with_vcr)
+      def request_with_vcr(*args, &block)
+        VCR::LibraryHooks::FakeWeb::RequestHandler.new(
+          self, *args, &block
+        ).handle
+      end
+
+      alias request_without_vcr request
+      alias request request_with_vcr
+    end
+  end
+end
+
+VCR.configuration.after_library_hooks_loaded do
+  if defined?(WebMock)
+    raise ArgumentError.new("You have configured VCR to hook into both :fakeweb and :webmock. You cannot use both.")
+  end
+end
+