vcr 1.2.0 → 1.3.0

data/Rakefile

@@ -23,10 +23,13 @@ task :cleanup_rcov_files do
 end
 
 permutations = {
-  'fakeweb' => %w( net/http ),
-  'webmock' => %w( net/http httpclient patron em-http-request curb )
+  'fakeweb'  => %w( net/http typhoeus ),
+  'typhoeus' => %w( typhoeus ),
+  'webmock'  => %w( net/http typhoeus httpclient patron em-http-request curb )
 }
 
+permutations.delete('typhoeus') if RUBY_INTERPRETER == :jruby
+
 require 'cucumber/rake/task'
 namespace :features do
   permutations.each do |http_stubbing_adapter, http_libraries|
@@ -35,6 +38,7 @@ namespace :features do
     namespace http_stubbing_adapter do
       http_libraries.each do |http_lib|
         next if RUBY_INTERPRETER != :mri && %w( patron em-http-request curb ).include?(http_lib)
+        next if RUBY_INTERPRETER == :jruby && http_lib == 'typhoeus'
 
         sanitized_http_lib = http_lib.gsub('/', '_')
         features_subtasks << "features:#{http_stubbing_adapter}:#{sanitized_http_lib}"

data/TODO.md

@@ -0,0 +1,4 @@
+* use `expect { }.to` rather than `lambda { }.should` in specs.
+* Use fakefs gem instead of using temp_dir in specs.
+* Use localhost server in specs instead of hitting example.com.
+* Fix #method vs .method in specs.

data/features/support/env.rb

@@ -43,7 +43,11 @@ YAML_SERIALIZATION_VERSION = RUBY_VERSION == '1.9.1' ? '1.9.1' : 'not_1.9.1'
 
 VCR.config do |c|
   c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', YAML_SERIALIZATION_VERSION)
-  c.http_stubbing_library = ENV['HTTP_STUBBING_ADAPTER'].to_sym
+
+  stubs = [ENV['HTTP_STUBBING_ADAPTER'].to_sym, :typhoeus].uniq
+  stubs.delete(:typhoeus) if RUBY_INTERPRETER == :jruby
+
+  c.stub_with *stubs
 end
 
 VCR.module_eval do

data/full_build

@@ -0,0 +1 @@
+rvm 1.8.6,1.8.7,1.9.1,1.9.2,ree,jruby,rbx-head rake -f FullBuildRakeFile build | tee tmp/full_build.out

data/lib/vcr.rb

@@ -9,6 +9,7 @@ require 'vcr/http_stubbing_adapters/common'
 module VCR
   extend self
 
+  autoload :BasicObject,        'vcr/basic_object'
   autoload :CucumberTags,       'vcr/cucumber_tags'
   autoload :InternetConnection, 'vcr/internet_connection'
   autoload :RSpec,              'vcr/rspec'
@@ -54,13 +55,22 @@ module VCR
   end
 
   def http_stubbing_adapter
-    @http_stubbing_adapter ||= case VCR::Config.http_stubbing_library
-      when :fakeweb
-        VCR::HttpStubbingAdapters::FakeWeb
-      when :webmock
-        VCR::HttpStubbingAdapters::WebMock
-      else
-        raise ArgumentError.new("The http stubbing library is not configured correctly.  You should set it to :webmock or :fakeweb.")
+    @http_stubbing_adapter ||= begin
+      if [:fakeweb, :webmock].all? { |l| VCR::Config.http_stubbing_libraries.include?(l) }
+        raise ArgumentError.new("You have configured VCR to use both :fakeweb and :webmock.  You cannot use both.")
+      end
+
+      adapters = VCR::Config.http_stubbing_libraries.map do |lib|
+        case lib
+          when :fakeweb;  HttpStubbingAdapters::FakeWeb
+          when :webmock;  HttpStubbingAdapters::WebMock
+          when :typhoeus; HttpStubbingAdapters::Typhoeus
+          else raise ArgumentError.new("#{lib.inspect} is not a supported HTTP stubbing library.")
+        end
+      end
+
+      raise ArgumentError.new("The http stubbing library is not configured.") if adapters.empty?
+      HttpStubbingAdapters::MultiObjectProxy.for(*adapters)
     end
   end
 

data/lib/vcr/basic_object.rb

@@ -0,0 +1,39 @@
+module VCR
+  # taken directly from backports:
+  # https://github.com/marcandre/backports/blob/v1.18.2/lib/backports/basic_object.rb
+  class BasicObject
+    KEEP = [:instance_eval, :instance_exec, :__send__,
+            "instance_eval", "instance_exec", "__send__"]
+    # undefine almost all instance methods
+    begin
+      old_verbose, $VERBOSE = $VERBOSE, nil # silence the warning for undefining __id__
+      (instance_methods - KEEP).each do |method|
+        undef_method method
+      end
+    ensure
+      $VERBOSE = old_verbose
+    end
+
+    class << self
+      def === (cmp)
+        true
+      end
+
+      # Let's try to keep things clean, in case methods have been added to Object
+      # either directly or through an included module.
+      # We'll do this whenever a class is derived from BasicObject
+      # Ideally, we'd do this by trapping Object.method_added
+      # and M.method_added for any module M included in Object or a submodule
+      # Seems really though to get right, but pull requests welcome ;-)
+      def inherited(sub)
+        BasicObject.class_eval do
+          (instance_methods - KEEP).each do |method|
+            if Object.method_defined?(method) && instance_method(method).owner == Object.instance_method(method).owner
+              undef_method method
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vcr/config.rb

@@ -16,12 +16,9 @@ module VCR
         @default_cassette_options
       end
 
-      attr_writer :http_stubbing_library
-      def http_stubbing_library
-        @http_stubbing_library ||= begin
-          defined_constants = [:FakeWeb, :WebMock].select { |c| Object.const_defined?(c) }
-          defined_constants[0].to_s.downcase.to_sym if defined_constants.size == 1
-        end
+      attr_reader :http_stubbing_libraries
+      def stub_with(*http_stubbing_libraries)
+        @http_stubbing_libraries = http_stubbing_libraries
       end
 
       def ignore_localhost=(value)
@@ -34,4 +31,4 @@ module VCR
       end
     end
   end
-end
+end

data/lib/vcr/deprecations.rb

@@ -1,4 +1,18 @@
 module VCR
+  class Config
+    class << self
+      def http_stubbing_library
+        warn "WARNING: `VCR::Config.http_stubbing_library` is deprecated.  Use `VCR::Config.http_stubbing_libraries` instead."
+        @http_stubbing_libraries && @http_stubbing_libraries.first
+      end
+
+      def http_stubbing_library=(library)
+        warn "WARNING: `VCR::Config.http_stubbing_library = #{library.inspect}` is deprecated.  Use `VCR::Config.stub_with #{library.inspect}` instead."
+        stub_with library
+      end
+    end
+  end
+
   class Cassette
     def allow_real_http_requests_to?(uri)
       warn "WARNING: VCR::Cassette#allow_real_http_requests_to? is deprecated and should no longer be used."

data/lib/vcr/http_stubbing_adapters/common.rb

@@ -1,38 +1,69 @@
 module VCR
   module HttpStubbingAdapters
-    autoload :FakeWeb, 'vcr/http_stubbing_adapters/fakeweb'
-    autoload :WebMock, 'vcr/http_stubbing_adapters/webmock'
+    autoload :FakeWeb,          'vcr/http_stubbing_adapters/fakeweb'
+    autoload :MultiObjectProxy, 'vcr/http_stubbing_adapters/multi_object_proxy'
+    autoload :Typhoeus,         'vcr/http_stubbing_adapters/typhoeus'
+    autoload :WebMock,          'vcr/http_stubbing_adapters/webmock'
 
     class UnsupportedRequestMatchAttributeError < ArgumentError; end
 
     module Common
+      def self.add_vcr_info_to_exception_message(exception_klass)
+        exception_klass.class_eval do
+          def message
+            super + ".  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"
+          end
+        end
+      end
+
       def check_version!
         version_too_low, version_too_high = compare_version
 
         if version_too_low
-          raise "You are using #{library_name} #{version}.  VCR requires version #{self::VERSION_REQUIREMENT} or greater."
+          raise "You are using #{library_name} #{version}.  VCR requires version #{version_requirement}."
         elsif version_too_high
-          warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} ~> #{self::VERSION_REQUIREMENT}.  It may not work with this version."
+          warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} #{version_requirement}.  It may not work with this version."
         end
       end
 
+      def library_name
+        @library_name ||= self.to_s.split('::').last
+      end
+
       private
 
       def compare_version
-        major,     minor,     patch     = *version.split('.').map { |v| v.to_i }
-        req_major, req_minor, req_patch = *self::VERSION_REQUIREMENT.split('.').map { |v| v.to_i }
+        major,     minor,     patch     = parse_version(version)
+        min_major, min_minor, min_patch = parse_version(self::MINIMUM_VERSION)
+        max_major, max_minor            = parse_version(self::MAXIMUM_VERSION)
 
-        return true, false if major < req_major
-        return false, true if major > req_major
+        return true, false if major < min_major
+        return false, true if major > max_major
 
-        return true, false if minor < req_minor
-        return false, true if minor > req_minor
+        return true, false if minor < min_minor
+        return false, true if minor > max_minor
 
-        return patch < req_patch, false
+        return patch < min_patch, false
       end
 
-      def library_name
-        @library_name ||= self.to_s.split('::').last
+      def version_requirement
+        max_major, max_minor = parse_version(self::MAXIMUM_VERSION)
+        ">= #{self::MINIMUM_VERSION}, < #{max_major}.#{max_minor + 1}"
+      end
+
+      def parse_version(version)
+        version.split('.').map { |v| v.to_i }
+      end
+
+      def grouped_responses(http_interactions, match_attributes)
+        responses = Hash.new { |h,k| h[k] = [] }
+
+        http_interactions.each do |i|
+          responses[i.request.matcher(match_attributes)] << i.response
+        end
+
+        responses
       end
     end
   end

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -10,26 +10,31 @@ module VCR
       UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES = [:body, :headers].freeze
       LOCALHOST_REGEX = %r|\Ahttps?://((\w+:)?\w+@)?(#{VCR::LOCALHOST_ALIASES.map { |a| Regexp.escape(a) }.join('|')})(:\d+)?/|i
 
-      VERSION_REQUIREMENT = '1.3.0'
+      MINIMUM_VERSION = '1.3.0'
+      MAXIMUM_VERSION = '1.3'
+
+      def http_connections_allowed=(value)
+        @http_connections_allowed = value
+        update_fakeweb_allow_net_connect
+      end
 
       def http_connections_allowed?
         !!::FakeWeb.allow_net_connect?("http://some.url/besides/localhost")
       end
 
-      def http_connections_allowed=(value)
-        @http_connections_allowed = value
+      def ignore_localhost=(value)
+        @ignore_localhost = value
         update_fakeweb_allow_net_connect
       end
 
+      def ignore_localhost?
+        !!@ignore_localhost
+      end
+
       def stub_requests(http_interactions, match_attributes)
         validate_match_attributes(match_attributes)
-        requests = Hash.new { |h,k| h[k] = [] }
-
-        http_interactions.each do |i|
-          requests[i.request.matcher(match_attributes)] << i.response
-        end
 
-        requests.each do |request_matcher, responses|
+        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
           ::FakeWeb.register_uri(
             request_matcher.method || :any,
             request_matcher.uri,
@@ -48,22 +53,13 @@ module VCR
 
       def request_stubbed?(request, match_attributes)
         validate_match_attributes(match_attributes)
-        ::FakeWeb.registered_uri?(request.method, request.uri)
+        !!::FakeWeb.registered_uri?(request.method, request.uri)
       end
 
       def request_uri(net_http, request)
         ::FakeWeb::Utility.request_uri_as_string(net_http, request)
       end
 
-      def ignore_localhost=(value)
-        @ignore_localhost = value
-        update_fakeweb_allow_net_connect
-      end
-
-      def ignore_localhost?
-        @ignore_localhost
-      end
-
       private
 
       def version
@@ -101,12 +97,5 @@ module VCR
   end
 end
 
-if defined?(FakeWeb::NetConnectNotAllowedError)
-  module FakeWeb
-    class NetConnectNotAllowedError
-      def message
-        super + ".  You can use VCR to automatically record this request and replay it later.  For more details, see the VCR README at: http://github.com/myronmarston/vcr/tree/v#{VCR.version}"
-      end
-    end
-  end
-end
+VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(FakeWeb::NetConnectNotAllowedError)
+

data/lib/vcr/http_stubbing_adapters/multi_object_proxy.rb

@@ -0,0 +1,43 @@
+module VCR
+  module HttpStubbingAdapters
+    class MultiObjectProxy < defined?(::BasicObject) ? ::BasicObject : VCR::BasicObject
+
+      def self.for(*objects)
+        return objects.first if objects.size == 1
+        new(*objects)
+      end
+
+      attr_reader :proxied_objects
+
+      def initialize(*objects)
+        ::Kernel.raise ::ArgumentError.new("You must pass at least one object to proxy to") if objects.empty?
+        ::Kernel.raise ::ArgumentError.new("Cannot proxy to nil") if objects.any? { |o| o.nil? }
+
+        @proxied_objects = objects
+      end
+
+      def respond_to?(message)
+        proxied_objects.any? { |o| o.respond_to?(message) }
+      end
+
+      private
+
+        def method_missing(name, *args)
+          responding_proxied_objects = proxied_objects.select { |o| o.respond_to?(name) }
+          return super if responding_proxied_objects.empty?
+
+          uniq_return_vals = responding_proxied_objects.map { |o| o.__send__(name, *args) }.uniq
+
+          return nil unless method_return_val_important?(name)
+          return uniq_return_vals.first if uniq_return_vals.size == 1
+
+          ::Kernel.raise "The proxied objects returned different values for calls to #{name}: #{uniq_return_vals.inspect}"
+        end
+
+        def method_return_val_important?(method_name)
+          method_name == :request_uri || method_name.to_s =~ /\?$/
+        end
+    end
+  end
+end
+

data/lib/vcr/http_stubbing_adapters/typhoeus.rb

@@ -0,0 +1,101 @@
+require 'typhoeus'
+
+module VCR
+  module HttpStubbingAdapters
+    module Typhoeus
+      include VCR::HttpStubbingAdapters::Common
+      extend self
+
+      MINIMUM_VERSION = '0.2.0'
+      MAXIMUM_VERSION = '0.2'
+
+      def http_connections_allowed=(value)
+        ::Typhoeus::Hydra.allow_net_connect = value
+      end
+
+      def http_connections_allowed?
+        !!::Typhoeus::Hydra.allow_net_connect?
+      end
+
+      def ignore_localhost=(value)
+        ::Typhoeus::Hydra.ignore_localhost = value
+      end
+
+      def ignore_localhost?
+        !!::Typhoeus::Hydra.ignore_localhost?
+      end
+
+      def stub_requests(http_interactions, match_attributes)
+        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
+          ::Typhoeus::Hydra.stub(
+            request_matcher.method || :any,
+            request_matcher.uri,
+            request_hash(request_matcher)
+          ).and_return(
+            responses.map do |response|
+              ::Typhoeus::Response.new(
+                :code         => response.status.code,
+                :body         => response.body,
+                :headers_hash => response.headers
+              )
+            end
+          )
+        end
+      end
+
+      def create_stubs_checkpoint(checkpoint_name)
+        checkpoints[checkpoint_name] = ::Typhoeus::Hydra.stubs.dup
+      end
+
+      def restore_stubs_checkpoint(checkpoint_name)
+        ::Typhoeus::Hydra.stubs = checkpoints.delete(checkpoint_name)
+      end
+
+      private
+
+      def version
+        ::Typhoeus::VERSION
+      end
+
+      def checkpoints
+        @checkpoints ||= {}
+      end
+
+      def request_hash(request_matcher)
+        hash = {}
+
+        hash[:body]    = request_matcher.body    if request_matcher.match_requests_on?(:body)
+        hash[:headers] = request_matcher.headers if request_matcher.match_requests_on?(:headers)
+
+        hash
+      end
+    end
+  end
+end
+
+Typhoeus::Hydra.after_request_before_on_complete do |request|
+  unless request.response.mock?
+    http_interaction = VCR::HTTPInteraction.new(
+      VCR::Request.new(
+        request.method,
+        request.url,
+        request.body,
+        request.headers
+      ),
+      VCR::Response.new(
+        VCR::ResponseStatus.new(
+          request.response.code,
+          request.response.status_message
+        ),
+        request.response.headers_hash,
+        request.response.body,
+        request.response.http_version
+      )
+    )
+
+    VCR.record_http_interaction(http_interaction)
+  end
+end
+
+VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(Typhoeus::Hydra::NetConnectNotAllowedError)
+