vcr 0.3.1 → 0.4.0

data/features/support/env.rb

@@ -13,6 +13,12 @@ require 'spec/expectations'
 
 VCR.config do |c|
   c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', RUBY_VERSION)
+  c.http_stubbing_library = if ENV['HTTP_STUBBING_ADAPTER'].to_s == ''
+    warn "Using fakeweb for VCR's cucumber features since the adapter was not specified.  Set HTTP_STUBBING_ADAPTER to specify."
+    :fakeweb
+  else
+    ENV['HTTP_STUBBING_ADAPTER'].to_sym
+  end
 end
 
 VCR.module_eval do

data/lib/vcr.rb

@@ -2,12 +2,12 @@ require 'vcr/cassette'
 require 'vcr/config'
 require 'vcr/cucumber_tags'
 require 'vcr/deprecations'
-require 'vcr/recorded_response'
+require 'vcr/structs'
 
-require 'vcr/extensions/fake_web'
-require 'vcr/extensions/net_http'
 require 'vcr/extensions/net_read_adapter'
 
+require 'vcr/http_stubbing_adapters/base'
+
 module VCR
   extend self
 
@@ -36,6 +36,8 @@ module VCR
 
   def config
     yield VCR::Config
+    http_stubbing_adapter.check_version!
+    http_stubbing_adapter.http_connections_allowed = false
   end
 
   def cucumber_tags(&block)
@@ -43,6 +45,17 @@ module VCR
     yield VCR::CucumberTags.new(main_object)
   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.")
+    end
+  end
+
   private
 
   def cassettes

data/lib/vcr/cassette.rb

@@ -10,92 +10,95 @@ module VCR
     def initialize(name, options = {})
       @name = name
       @record_mode = options[:record] || VCR::Config.default_cassette_options[:record]
-      deprecate_unregistered_record_mode
       @allow_real_http_lambda = allow_real_http_lambda_for(options[:allow_real_http] || VCR::Config.default_cassette_options[:allow_real_http])
-      self.class.raise_error_unless_valid_record_mode(record_mode)
-      set_fakeweb_allow_net_connect
-      load_recorded_responses
+
+      deprecate_unregistered_record_mode
+      raise_error_unless_valid_record_mode(record_mode)
+
+      set_http_connections_allowed
+      load_recorded_interactions
     end
 
     def eject
-      write_recorded_responses_to_disk
-      deregister_original_recorded_responses
-      restore_fakeweb_allow_net_conect
+      write_recorded_interactions_to_disk
+      VCR.http_stubbing_adapter.restore_stubs_checkpoint(name)
+      restore_http_connections_allowed
     end
 
-    def recorded_responses
-      @recorded_responses ||= []
+    def recorded_interactions
+      @recorded_interactions ||= []
     end
 
-    def store_recorded_response!(recorded_response)
-      recorded_responses << recorded_response
+    def record_http_interaction(interaction)
+      recorded_interactions << interaction
     end
 
     def file
       File.join(VCR::Config.cassette_library_dir, "#{name.to_s.gsub(/[^\w\-\/]+/, '_')}.yml") if VCR::Config.cassette_library_dir
     end
 
-    def self.raise_error_unless_valid_record_mode(record_mode)
+    def allow_real_http_requests_to?(uri)
+      @allow_real_http_lambda ? @allow_real_http_lambda.call(uri) : false
+    end
+
+    private
+
+    def raise_error_unless_valid_record_mode(record_mode)
       unless VALID_RECORD_MODES.include?(record_mode)
         raise ArgumentError.new("#{record_mode} is not a valid cassette record mode.  Valid options are: #{VALID_RECORD_MODES.inspect}")
       end
     end
 
-    def allow_real_http_requests_to?(uri)
-      @allow_real_http_lambda ? @allow_real_http_lambda.call(uri) : false
+    def new_recorded_interactions
+      recorded_interactions - @original_recorded_interactions
     end
 
-    def new_recorded_responses
-      recorded_responses - @original_recorded_responses
-    end
-
-    def should_allow_net_connect?
+    def should_allow_http_connections?
       [:new_episodes, :all].include?(record_mode)
     end
 
-    def set_fakeweb_allow_net_connect
-      @orig_fakeweb_allow_connect = FakeWeb.allow_net_connect?
-      FakeWeb.allow_net_connect = should_allow_net_connect?
+    def set_http_connections_allowed
+      @orig_http_connections_allowed = VCR.http_stubbing_adapter.http_connections_allowed?
+      VCR.http_stubbing_adapter.http_connections_allowed = should_allow_http_connections?
     end
 
-    def restore_fakeweb_allow_net_conect
-      FakeWeb.allow_net_connect = @orig_fakeweb_allow_connect
+    def restore_http_connections_allowed
+      VCR.http_stubbing_adapter.http_connections_allowed = @orig_http_connections_allowed
     end
 
-    def load_recorded_responses
-      @original_recorded_responses = []
+    def load_recorded_interactions
+      VCR.http_stubbing_adapter.create_stubs_checkpoint(name)
+      @original_recorded_interactions = []
       return if record_mode == :all
 
       if file
-        @original_recorded_responses = File.open(file, 'r') { |f| YAML.load(f.read) } if File.exist?(file)
-        recorded_responses.replace(@original_recorded_responses)
+        @original_recorded_interactions = begin
+          yaml_content = File.read(file)
+          YAML.load(yaml_content)
+        rescue TypeError
+          if yaml_content =~ /VCR::RecordedResponse/
+            raise "The VCR cassette #{name} uses an old format that is now deprecated.  VCR provides a rake task to migrate your old cassettes to the new format.  See http://github.com/myronmarston/vcr/blob/master/CHANGELOG.md for more info."
+          else
+            raise
+          end
+        end if File.exist?(file)
+
+        recorded_interactions.replace(@original_recorded_interactions)
       end
 
-      register_responses_with_fakeweb
+      VCR.http_stubbing_adapter.stub_requests(recorded_interactions)
     end
 
-    def register_responses_with_fakeweb
-      requests = Hash.new([])
-      recorded_responses.each do |rr|
-        requests[[rr.method, rr.uri]] += [rr.response]
-      end
-      requests.each do |request, responses|
-        FakeWeb.register_uri(request.first, request.last, responses.map{ |r| { :response => r } })
-      end
-    end
-
-    def write_recorded_responses_to_disk
-      if VCR::Config.cassette_library_dir && new_recorded_responses.size > 0
+    def write_recorded_interactions_to_disk
+      if VCR::Config.cassette_library_dir && new_recorded_interactions.size > 0
         directory = File.dirname(file)
         FileUtils.mkdir_p directory unless File.exist?(directory)
-        File.open(file, 'w') { |f| f.write recorded_responses.to_yaml }
+        File.open(file, 'w') { |f| f.write recorded_interactions.to_yaml }
       end
     end
 
-    def deregister_original_recorded_responses
-      @original_recorded_responses.each do |rr|
-        FakeWeb.remove_from_registry(rr.method, rr.uri)
-      end
+    def unstub_requests
+      VCR.http_stubbing_adapter.unstub_requests(@original_recorded_interactions)
     end
 
     def allow_real_http_lambda_for(allow_option)

data/lib/vcr/config.rb

@@ -13,6 +13,14 @@ module VCR
       def default_cassette_options
         @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
+      end
     end
   end
 end

data/lib/vcr/extensions/fake_web.rb

@@ -1,34 +1,20 @@
-require 'fake_web'
+require 'fakeweb'
 
 module FakeWeb
-  def self.remove_from_registry(method, url)
-    Registry.instance.remove(method, url)
-  end
+  def self.request_uri(net_http, request)
+    # Copied from: http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L39-52
+    protocol = net_http.use_ssl? ? "https" : "http"
 
-  def self.with_allow_net_connect_set_to(value)
-    original_value = FakeWeb.allow_net_connect?
-    begin
-      FakeWeb.allow_net_connect = value
-      yield
-    ensure
-      FakeWeb.allow_net_connect = original_value
-    end
-  end
+    path = request.path
+    path = URI.parse(request.path).request_uri if request.path =~ /^http/
 
-  class Registry #:nodoc:
-    def remove(method, url)
-      uri_map.delete_if do |uri, method_hash|
-        if normalize_uri(uri) == normalize_uri(url)
-          method_hash.delete(method)
-          method_hash.empty? # there's no point in keeping this entry in the uri map if its method hash is empty...
-        end
-      end
+    if request["authorization"] =~ /^Basic /
+      userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
+      userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
+    else
+      userinfo = ""
     end
-  end
 
-  class NetConnectNotAllowedError
-    def message
-      super + '.  You can use VCR to automatically record this request and replay it later with fakeweb.  For more details, see the VCR README at: http://github.com/myronmarston/vcr'
-    end
+    "#{protocol}://#{userinfo}#{net_http.address}:#{net_http.port}#{path}"
   end
 end

data/lib/vcr/extensions/net_http.rb

@@ -3,48 +3,31 @@ require 'net/http'
 module Net
   class HTTP
     def request_with_vcr(request, body = nil, &block)
-      @__request_with_vcr_call_count = (@__request_with_vcr_call_count || 0) + 1
-      uri = URI.parse(__vcr_uri__(request))
+      uri = URI.parse(VCR.http_stubbing_adapter.request_uri(self, request))
+
       if (cassette = VCR.current_cassette) && cassette.allow_real_http_requests_to?(uri)
-        FakeWeb.with_allow_net_connect_set_to(true) { request_without_vcr(request, body, &block) }
+        VCR.http_stubbing_adapter.with_http_connections_allowed_set_to(true) do
+          request_without_vcr(request, body, &block)
+        end
       else
         response = request_without_vcr(request, body)
-        __store_response_with_vcr__(response, request) if @__request_with_vcr_call_count == 1
+        __store_response_with_vcr__(response, request) if started?
         yield response if block_given?
         response
       end
-    ensure
-      @__request_with_vcr_call_count -= 1
     end
     alias_method :request_without_vcr, :request
     alias_method :request, :request_with_vcr
 
     private
 
-    def __vcr_uri__(request)
-      # Copied from: http://github.com/chrisk/fakeweb/blob/fakeweb-1.2.8/lib/fake_web/ext/net_http.rb#L39-52
-      protocol = use_ssl? ? "https" : "http"
-
-      path = request.path
-      path = URI.parse(request.path).request_uri if request.path =~ /^http/
-
-      if request["authorization"] =~ /^Basic /
-        userinfo = FakeWeb::Utility.decode_userinfo_from_header(request["authorization"])
-        userinfo = FakeWeb::Utility.encode_unsafe_chars_in_userinfo(userinfo) + "@"
-      else
-        userinfo = ""
-      end
-
-      "#{protocol}://#{userinfo}#{self.address}:#{self.port}#{path}"
-    end
-
     def __store_response_with_vcr__(response, request)
       if cassette = VCR.current_cassette
-        uri = __vcr_uri__(request)
+        uri = VCR.http_stubbing_adapter.request_uri(self, request)
         method = request.method.downcase.to_sym
 
-        unless FakeWeb.registered_uri?(method, uri)
-          cassette.store_recorded_response!(VCR::RecordedResponse.new(method, uri, response))
+        unless VCR.http_stubbing_adapter.request_stubbed?(method, uri)
+          cassette.record_http_interaction(VCR::HTTPInteraction.from_net_http_objects(self, request, response))
         end
       end
     end

data/lib/vcr/http_stubbing_adapters/base.rb

@@ -0,0 +1,34 @@
+module VCR
+  module HttpStubbingAdapters
+    autoload :FakeWeb, 'vcr/http_stubbing_adapters/fakeweb'
+    autoload :WebMock, 'vcr/http_stubbing_adapters/webmock'
+
+    class Base
+      class << self
+        def with_http_connections_allowed_set_to(value)
+          original_value = http_connections_allowed?
+          self.http_connections_allowed = value
+          begin
+            yield
+          ensure
+            self.http_connections_allowed = original_value
+          end
+        end
+
+        def meets_version_requirement?(version, required_version)
+          major,     minor,     patch     = *version.split('.').map { |v| v.to_i }
+          req_major, req_minor, req_patch = *required_version.split('.').map { |v| v.to_i }
+
+          return false if major < req_major
+          return true  if major > req_major
+
+          return false if minor < req_minor
+          return true  if minor > req_minor
+
+          patch >= req_patch
+        end
+
+      end
+    end
+  end
+end

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -0,0 +1,75 @@
+require 'vcr/extensions/fake_web'
+require 'vcr/extensions/net_http'
+
+module VCR
+  module HttpStubbingAdapters
+    class FakeWeb < Base
+      class << self
+        def check_version!
+          unless meets_version_requirement?(::FakeWeb::VERSION, '1.2.8')
+            raise "You are using FakeWeb #{::FakeWeb::VERSION}.  VCR requires version 1.2.8 or greater."
+          end
+        end
+
+        def http_connections_allowed?
+          ::FakeWeb.allow_net_connect?
+        end
+
+        def http_connections_allowed=(value)
+          ::FakeWeb.allow_net_connect = value
+        end
+
+        def stub_requests(http_interactions)
+          requests = Hash.new([])
+
+          http_interactions.each do |i|
+            requests[[i.request.method, i.request.uri]] += [i.response]
+          end
+
+          requests.each do |request, responses|
+            ::FakeWeb.register_uri(request.first, request.last, responses.map{ |r| response_hash(r) })
+          end
+        end
+
+        def create_stubs_checkpoint(checkpoint_name)
+          checkpoints[checkpoint_name] = ::FakeWeb::Registry.instance.uri_map.dup
+        end
+
+        def restore_stubs_checkpoint(checkpoint_name)
+          ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(checkpoint_name)
+        end
+
+        def request_stubbed?(method, uri)
+          ::FakeWeb.registered_uri?(method, uri)
+        end
+
+        def request_uri(net_http, request)
+          ::FakeWeb.request_uri(net_http, request)
+        end
+
+        private
+
+        def checkpoints
+          @checkpoints ||= {}
+        end
+
+        def response_hash(response)
+          response.headers.merge(
+            :body   => response.body,
+            :status => [response.status.code.to_s, response.status.message]
+          )
+        end
+      end
+    end
+  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'
+      end
+    end
+  end
+end

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -0,0 +1,80 @@
+require 'webmock'
+require 'vcr/extensions/net_http'
+
+module VCR
+  module HttpStubbingAdapters
+    class WebMock < Base
+      class << self
+        VERSION_REQUIREMENT = '1.1.0'
+
+        def check_version!
+          unless meets_version_requirement?(::WebMock.version, VERSION_REQUIREMENT)
+            raise "You are using WebMock #{::WebMock.version}.  VCR requires version #{VERSION_REQUIREMENT} or greater."
+          end
+        end
+
+        def http_connections_allowed?
+          ::WebMock::Config.instance.allow_net_connect
+        end
+
+        def http_connections_allowed=(value)
+          ::WebMock::Config.instance.allow_net_connect = value
+        end
+
+        def stub_requests(recorded_responses)
+          requests = Hash.new([])
+
+          # TODO: use the entire request signature, but make it configurable.
+          recorded_responses.each do |rr|
+            requests[[rr.method, rr.uri]] += [rr.response]
+          end
+
+          requests.each do |request, responses|
+            ::WebMock.stub_request(request.first, request.last).
+              to_return(responses.map{ |r| response_hash(r) })
+          end
+        end
+
+        def create_stubs_checkpoint(checkpoint_name)
+          checkpoints[checkpoint_name] = ::WebMock::RequestRegistry.instance.request_stubs.dup
+        end
+
+        def restore_stubs_checkpoint(checkpoint_name)
+          ::WebMock::RequestRegistry.instance.request_stubs = checkpoints.delete(checkpoint_name)
+        end
+
+        def request_stubbed?(method, uri)
+          !!::WebMock.registered_request?(::WebMock::RequestSignature.new(method, uri))
+        end
+
+        def request_uri(net_http, request)
+          ::WebMock::NetHTTPUtility.request_signature_from_request(net_http, request).uri.to_s
+        end
+
+        private
+
+        def response_hash(response)
+          {
+            :body    => response.body,
+            :status  => [response.status.code.to_i, response.status.message],
+            :headers => response.headers
+          }
+        end
+
+        def checkpoints
+          @checkpoints ||= {}
+        end
+      end
+    end
+  end
+end
+
+if defined?(WebMock::NetConnectNotAllowedError)
+  module WebMock
+    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'
+      end
+    end
+  end
+end