vcr 2.0.0.rc1 → 2.0.0.rc2

data/lib/vcr/test_frameworks/cucumber.rb

@@ -1,20 +1,30 @@
 module VCR
+  # Provides integration with Cucumber using tags.
   class CucumberTags
     class << self
+      # @private
       def tags
         @tags.dup
       end
 
+      # @private
       def add_tag(tag)
         @tags << tag
       end
     end
 
     @tags = []
+
+    # @private
     def initialize(main_object)
       @main_object = main_object
     end
 
+    # Adds +Before+ and +After+ cucumber hooks for the named tags that
+    # will cause a VCR cassette to be used for scenarios with matching tags.
+    #
+    # @param [Array<String>] tag_names the cucumber scenario tags
+    # @param [(optional) Hash] options the cassette options
     def tags(*tag_names)
       options = tag_names.last.is_a?(::Hash) ? tag_names.pop : {}
       tag_names.each do |tag_name|

data/lib/vcr/test_frameworks/rspec.rb

@@ -1,6 +1,30 @@
 module VCR
+  # Integrates VCR with RSpec.
   module RSpec
+
+    # Contains macro methods to assist with VCR usage. These methods are
+    # intended to be used directly in an RSpec example group. To make these
+    # available in your RSpec example groups, extend the module in an individual
+    # example group, or configure RSpec to extend the module in all example groups.
+    #
+    # @example
+    #   RSpec.configure do |c|
+    #     c.extend VCR::RSpec::Macros
+    #   end
+    #
     module Macros
+
+      # Sets up a +before+ and +after+ hook that will insert and eject a
+      # cassette, respectively.
+      #
+      # @example
+      #   describe "Some API Client" do
+      #     use_vcr_cassette "some_api", :record => :new_episodes
+      #   end
+      #
+      # @param [(optional) String] name the cassette name; it will be inferred by the example
+      #  group descriptions if not given.
+      # @param [(optional) Hash] options the cassette options
       def use_vcr_cassette(*args)
         options = args.last.is_a?(Hash) ? args.pop : {}
         name    = args.first || infer_cassette_name
@@ -33,6 +57,7 @@ module VCR
       end
     end
 
+    # @private
     module Metadata
       extend self
 
@@ -50,7 +75,7 @@ module VCR
 
           config.around(:each, :vcr => lambda { |v| !!v }) do |example|
             options = example.metadata[:vcr]
-            options = {} unless options.is_a?(Hash) # in case it's just :vcr => true
+            options = options.is_a?(Hash) ? options.dup : {} # in case it's just :vcr => true
 
             cassette_name = options.delete(:cassette_name) ||
                             vcr_cassette_name_for[example.metadata]

data/lib/vcr/util/hooks.rb

@@ -1,20 +1,32 @@
 require 'vcr/util/variable_args_block_caller'
 
 module VCR
+  # @private
   module Hooks
     include VariableArgsBlockCaller
 
-    def self.included(klass)
-      klass.extend(ClassMethods)
+    FilteredHook = Struct.new(:hook, :filters) do
+      include VariableArgsBlockCaller
+
+      def conditionally_invoke(*args)
+        filters = Array(self.filters)
+        return if filters.any? { |f| !call_block(f.to_proc, *args) }
+        call_block(hook, *args)
+      end
     end
 
-    def invoke_hook(hook, *args)
-      invoke_tagged_hook(hook, nil, *args)
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        hooks_module = Module.new
+        const_set("DefinedHooks", hooks_module)
+        include hooks_module
+      end
     end
 
-    def invoke_tagged_hook(hook, tag, *args)
-      hooks_for(hook, tag).map do |callback|
-        call_block(callback, *args)
+    def invoke_hook(hook_type, *args)
+      hooks[hook_type].map do |hook|
+        hook.conditionally_invoke(*args)
       end
     end
 
@@ -22,36 +34,26 @@ module VCR
       hooks.clear
     end
 
-  private
-
     def hooks
-      @hooks ||= Hash.new do |hook_type_hash, hook_type|
-        hook_type_hash[hook_type] = Hash.new do |tag_hash, tag|
-          tag_hash[tag] = []
-        end
+      @hooks ||= Hash.new do |hash, hook_type|
+        hash[hook_type] = []
       end
     end
 
-    def hooks_for(hook, tag)
-      for_hook = hooks[hook]
-      hooks = for_hook[tag] # matching tagged hooks
-      hooks += for_hook[nil] unless tag.nil? # untagged hooks
-      hooks
+    def has_hooks_for?(hook_type)
+      hooks[hook_type].any?
     end
 
+    # @private
     module ClassMethods
-      def define_hook(hook, prepend = false)
+      def define_hook(hook_type, prepend = false)
         placement_method = prepend ? :unshift : :<<
 
-        # We use splat args here because 1.8.7 doesn't allow default
-        # values for block arguments, so we have to fake it.
-        define_method hook do |*args, &block|
-          if args.size > 1
-            raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)")
+        # Put the hook methods in a module so we can override and super to these methods.
+        self::DefinedHooks.module_eval do
+          define_method hook_type do |*filters, &hook|
+            hooks[hook_type].send(placement_method, FilteredHook.new(hook, filters))
           end
-
-          tag = args.first
-          hooks[hook][tag].send(placement_method, block)
         end
       end
     end

data/lib/vcr/util/internet_connection.rb

@@ -9,6 +9,7 @@ module VCR
     require 'timeout'
     require "socket"
 
+    # @private
     module Ping
       def pingecho(host, timeout=5, service="echo")
         begin
@@ -27,6 +28,7 @@ module VCR
     end
   end
 
+  # @private
   module InternetConnection
     extend self
 

data/lib/vcr/util/logger.rb

@@ -0,0 +1,25 @@
+module VCR
+  # @private
+  module Logger
+    def log(message, indentation_level = 0)
+      indentation = '  ' * indentation_level
+      log_message = indentation + log_prefix + message
+      VCR.configuration.debug_logger.puts log_message
+    end
+
+    def log_prefix
+      ''
+    end
+
+    def request_summary(request, request_matchers)
+      attributes = [request.method, request.uri]
+      attributes << request.body.to_s[0, 80].inspect if request_matchers.include?(:body)
+      attributes << request.headers.inspect          if request_matchers.include?(:headers)
+      "[#{attributes.join(" ")}]"
+    end
+
+    def response_summary(response)
+      "[#{response.status.code} #{response.body[0, 80].inspect}]"
+    end
+  end
+end

data/lib/vcr/util/variable_args_block_caller.rb

@@ -1,4 +1,5 @@
 module VCR
+  # @private
   module VariableArgsBlockCaller
     def call_block(block, *args)
       if block.arity >= 0

data/lib/vcr/util/version_checker.rb

@@ -1,4 +1,5 @@
 module VCR
+  # @private
   class VersionChecker
     def initialize(library_name, library_version, min_patch_level, max_minor_version)
       @library_name, @library_version = library_name, library_version

data/lib/vcr/version.rb

@@ -1,9 +1,16 @@
 module VCR
   extend self
 
+  # @return [String] the current VCR version.
+  # @note This string also has singleton methods:
+  #
+  #   * `major` [Integer] The major version.
+  #   * `minor` [Integer] The minor version.
+  #   * `patch` [Integer] The patch version.
+  #   * `parts` [Array<Integer>] List of the version parts.
   def version
     @version ||= begin
-      string = '2.0.0.rc1'
+      string = '2.0.0.rc2'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/spec/capture_warnings.rb

@@ -1,11 +1,11 @@
+require 'rubygems' if RUBY_VERSION =~ /^1\.8/
+require 'rspec/core'
+require 'rspec/expectations'
 require 'tempfile'
 stderr_file = Tempfile.new("vcr.stderr")
 $stderr.reopen(stderr_file.path)
 current_dir = Dir.pwd
 
-require 'rubygems' if RUBY_VERSION =~ /^1\.8/
-require 'rspec/core'
-
 RSpec.configure do |config|
   config.after(:suite) do
     stderr_file.rewind

data/spec/monkey_patches.rb

@@ -14,8 +14,6 @@ module MonkeyPatches
 
   ALL_MONKEY_PATCHES = NET_HTTP_MONKEY_PATCHES.dup
 
-  ALL_MONKEY_PATCHES << [Typhoeus::Hydra::Stubbing::SharedMethods, :find_stub_from_request] if defined?(::Typhoeus)
-
   def enable!(scope)
     case scope
       when :fakeweb
@@ -25,12 +23,21 @@ module MonkeyPatches
         ::WebMock.reset!
         ::WebMock::HttpLibAdapters::NetHttpAdapter.enable!
         ::WebMock::HttpLibAdapters::TyphoeusAdapter.enable! if defined?(::Typhoeus)
+        ::WebMock::HttpLibAdapters::ExconAdapter.enable! if defined?(::Excon)
         $original_webmock_callbacks.each do |cb|
           ::WebMock::CallbackRegistry.add_callback(cb[:options], cb[:block])
         end
       when :typhoeus
-        Typhoeus::Hydra.global_hooks = $original_typhoeus_hooks
-        realias Typhoeus::Hydra::Stubbing::SharedMethods, :find_stub_from_request, :with_vcr
+        ::Typhoeus::Hydra.global_hooks = $original_typhoeus_global_hooks
+        ::Typhoeus::Hydra.stub_finders.clear
+        $original_typhoeus_stub_finders.each do |finder|
+          ::Typhoeus::Hydra.stub_finders << finder
+        end
+      when :excon
+        $original_excon_stubs.each do |stub|
+          ::Excon.stubs << stub
+        end
+        ::Excon.defaults[:mock] = true
       when :vcr
         realias Net::HTTP, :request, :with_vcr
       else raise ArgumentError.new("Unexpected scope: #{scope}")
@@ -43,12 +50,19 @@ module MonkeyPatches
     if defined?(::WebMock::HttpLibAdapters)
       ::WebMock::HttpLibAdapters::NetHttpAdapter.disable!
       ::WebMock::HttpLibAdapters::TyphoeusAdapter.disable! if defined?(::Typhoeus)
+      ::WebMock::HttpLibAdapters::ExconAdapter.disable! if defined?(::Excon)
       ::WebMock::CallbackRegistry.reset
       ::WebMock::StubRegistry.instance.request_stubs = []
     end
 
     if defined?(::Typhoeus)
-      Typhoeus::Hydra.clear_global_hooks
+      ::Typhoeus::Hydra.clear_global_hooks
+      ::Typhoeus::Hydra.stub_finders.clear
+    end
+
+    if defined?(::Excon)
+      ::Excon.stubs.clear
+      ::Excon.defaults[:mock] = false
     end
   end
 
@@ -118,15 +132,13 @@ unless RUBY_INTERPRETER == :jruby
   require 'curb'
 
   require 'vcr/library_hooks/typhoeus'
-  $original_typhoeus_hooks = Typhoeus::Hydra.global_hooks.dup
-
-  # define an alias that we can re-alias to in the future
-  Typhoeus::Hydra::Stubbing::SharedMethods.class_eval do
-    alias find_stub_from_request_with_vcr find_stub_from_request
-  end
+  $typhoeus_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
+  $original_typhoeus_global_hooks = Typhoeus::Hydra.global_hooks.dup
+  $original_typhoeus_stub_finders = Typhoeus::Hydra.stub_finders.dup
 end
 
 require 'vcr/library_hooks/fakeweb'
+$fakeweb_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
 
 # All Net::HTTP monkey patches have now been loaded, so capture the
 # appropriate method definitions so we can disable them later.
@@ -139,14 +151,17 @@ MonkeyPatches.disable_all!
 require 'vcr/library_hooks/webmock'
 $original_webmock_callbacks = ::WebMock::CallbackRegistry.callbacks
 
+require 'vcr/library_hooks/excon'
+$excon_after_loaded_hook = VCR.configuration.hooks[:after_library_hooks_loaded].last
+$original_excon_stubs = ::Excon.stubs.dup
+
 # disable all by default; we'll enable specific ones when we need them
 MonkeyPatches.disable_all!
 
 RSpec.configure do |config|
-  [:fakeweb, :webmock, :vcr, :typhoeus].each do |scope|
+  [:fakeweb, :webmock, :vcr, :typhoeus, :excon].each do |scope|
     config.before(:all, :with_monkey_patches => scope) { MonkeyPatches.enable!(scope) }
     config.after(:all,  :with_monkey_patches => scope) { MonkeyPatches.disable_all!   }
   end
 end
 
-require 'vcr/library_hooks/excon'

data/spec/spec_helper.rb

@@ -1,4 +1,21 @@
 require 'rubygems'
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter "/spec"
+  add_filter "/features"
+
+  # internet_connection mostly contains logic copied from the ruby 1.8.7
+  # stdlib for which I haven't written tests.
+  add_filter "internet_connection"
+end
+
+SimpleCov.at_exit do
+  File.open(File.join(SimpleCov.coverage_path, 'coverage_percent.txt'), 'w') do |f|
+    f.write SimpleCov.result.covered_percent
+  end
+  SimpleCov.result.format!
+end
 
 using_git = File.exist?(File.expand_path('../../.git/', __FILE__))
 if using_git

data/spec/support/http_library_adapters.rb

@@ -90,7 +90,8 @@ HTTP_LIBRARY_ADAPTERS['em-http-request'] = Module.new do
   end
 
   def get_header(header_key, response)
-    response.response_header[header_key.upcase.gsub('-', '_')].split(', ')
+    values = response.response_header[header_key.upcase.gsub('-', '_')]
+    values.is_a?(Array) ? values : values.split(', ')
   end
 
   def make_http_request(method, url, body = nil, headers = {})
@@ -116,11 +117,13 @@ HTTP_LIBRARY_ADAPTERS['curb'] = Module.new do
 
   def get_header(header_key, response)
     headers = response.header_str.split("\r\n")[1..-1]
+    value = nil
     headers.each do |h|
-      if h =~ /^#{Regexp.escape(header_key)}: (.*)$/
-        return $1.split(', ')
-      end
+      next unless h =~ /^#{Regexp.escape(header_key)}: (.*)$/
+      new_value = $1.split(', ')
+      value = value ? Array(value) + Array(new_value) : new_value
     end
+    value
   end
 
   def make_http_request(method, url, body = nil, headers = {})

data/spec/support/shared_example_groups/hook_into_http_library.rb

@@ -27,28 +27,10 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           end
         end
 
-        define_method :should_be_pending do
-          if header_count == 2
-            [
-              'HTTP Client',
-              'EM HTTP Request',
-              'Curb'
-            ].include?(adapter_module.http_library_name)
-          end
-        end
-
         it 'returns the same header value when recording and replaying' do
-          pending "There appears to be a bug in the the HTTP stubbing library", :if => should_be_pending do
-            (recorded_val = get_set_cookie_header).should_not be_nil
-            replayed_val = get_set_cookie_header
-
-            # we don't care about order differences if the values are arrays
-            if recorded_val.is_a?(Array) && replayed_val.is_a?(Array)
-              replayed_val.should =~ recorded_val
-            else
-              replayed_val.should eq(recorded_val)
-            end
-          end
+          (recorded_val = get_set_cookie_header).should_not be_nil
+          replayed_val = get_set_cookie_header
+          replayed_val.should eq(recorded_val)
         end
       end
     end
@@ -109,6 +91,22 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
       test_playback "with an encoded ampersand",        "http://example.com:80/search?q=#{CGI.escape("Q&A")}"
     end
 
+    it 'does not query the http interaction list excessively' do
+      call_count = 0
+      [:has_interaction_matching?, :response_for].each do |method_name|
+        orig_meth = VCR.http_interactions.method(method_name)
+        VCR.http_interactions.stub(method_name) do |*args|
+          call_count += 1
+          orig_meth.call(*args)
+        end
+      end
+
+      VCR.insert_cassette('foo')
+      make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/foo")
+
+      call_count.should eq(1)
+    end
+
     describe "using the library's stubbing/disconnection APIs" do
       let!(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
 
@@ -151,13 +149,6 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
 
     describe "request hooks" do
       context 'when there is an around_http_request hook' do
-        before(:each) do
-          # ensure that all the other library hooks are disabled so that we don't
-          # get double-hookage (such as for WebMock and Typhoeus both invoking the
-          # hooks for a typhoeus request)
-          VCR.library_hooks.stub(:disabled?) { |lib_name| lib_name != library_hook_name }
-        end
-
         let(:request_url) { "http://localhost:#{VCR::SinatraApp.port}/foo" }
 
         it 'yields the request to the block' do
@@ -175,6 +166,19 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           yielded_request.uri.should eq(request_url)
         end
 
+        it 'returns the response from request.proceed' do
+          response = nil
+          VCR.configuration.around_http_request do |request|
+            response = request.proceed
+          end
+
+          VCR.use_cassette('new_cassette') do
+            make_http_request(:get, request_url)
+          end
+
+          response.body.should eq("FOO!")
+        end
+
         it 'can be used to use a cassette for a request' do
           VCR.configuration.around_http_request do |request|
             VCR.use_cassette('new_cassette', &request)
@@ -232,20 +236,80 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
 
           3.times { make_http_request(:get, request_url) }
         end
+
+        it 'allows the hook to be filtered' do
+          order = []
+          VCR.configure do |c|
+            c.ignore_request { |r| true }
+            c.around_http_request(lambda { |r| r.uri =~ /foo/}) do |request|
+              order << :before_foo
+              request.proceed
+              order << :after_foo
+            end
+
+            c.around_http_request(lambda { |r| r.uri !~ /foo/}) do |request|
+              order << :before_not_foo
+              request.proceed
+              order << :after_not_foo
+            end
+          end
+
+          make_http_request(:get, request_url)
+          order.should eq([:before_foo, :after_foo])
+        end
+
+        it 'ensures that both around/before are invoked or neither' do
+          order = []
+          allow_1, allow_2 = false, true
+          VCR.configure do |c|
+            c.ignore_request { |r| true }
+            c.around_http_request(lambda { |r| allow_1 = !allow_1 }) do |request|
+              order << :before_1
+              request.proceed
+              order << :after_1
+            end
+
+            c.around_http_request(lambda { |r| allow_2 = !allow_2 }) do |request|
+              order << :before_2
+              request.proceed
+              order << :after_2
+            end
+          end
+
+          make_http_request(:get, request_url)
+          order.should eq([:before_1, :after_1])
+        end
       end if RUBY_VERSION >= '1.9'
 
+      it 'correctly assigns the correct type to both before and after request hooks, even if they are different' do
+        before_type = after_type = nil
+        VCR.configuration.before_http_request do |request|
+          before_type = request.type
+          VCR.insert_cassette('example')
+        end
+
+        VCR.configuration.after_http_request do |request|
+          after_type = request.type
+          VCR.eject_cassette
+        end
+
+        make_http_request(:get, "http://localhost:#{VCR::SinatraApp.port}/foo")
+        before_type.should be(:unhandled)
+        after_type.should be(:recordable)
+      end
+
       context "when the request is ignored" do
         before(:each) do
           VCR.configuration.ignore_request { |r| true }
         end
 
-        it_behaves_like "request hooks", library_hook_name
+        it_behaves_like "request hooks", library_hook_name, :ignored
       end
 
       context 'when the request is recorded' do
         let!(:inserted_cassette) { VCR.insert_cassette('new_cassette') }
 
-        it_behaves_like "request hooks", library_hook_name do
+        it_behaves_like "request hooks", library_hook_name, :recordable do
           let(:string_in_cassette) { 'example.com get response 1 with path=foo' }
 
           it 'plays back the cassette when a request is made' do
@@ -277,11 +341,11 @@ shared_examples_for "a hook into an HTTP library" do |library_hook_name, library
           stub_requests([http_interaction(request_url)], [:method, :uri])
         end
 
-        it_behaves_like "request hooks", library_hook_name
+        it_behaves_like "request hooks", library_hook_name, :stubbed
       end
 
       context 'when the request is not allowed' do
-        it_behaves_like "request hooks", library_hook_name do
+        it_behaves_like "request hooks", library_hook_name, :unhandled do
           undef assert_expected_response
           def assert_expected_response(response)
             response.should be_nil