vcr 2.9.3 → 3.0.0

data/lib/vcr/cassette.rb

@@ -81,8 +81,10 @@ module VCR
 
     # @private
     def record_http_interaction(interaction)
-      log "Recorded HTTP interaction #{request_summary(interaction.request)} => #{response_summary(interaction.response)}"
-      new_recorded_interactions << interaction
+      VCR::CassetteMutex.synchronize do
+        log "Recorded HTTP interaction #{request_summary(interaction.request)} => #{response_summary(interaction.response)}"
+        new_recorded_interactions << interaction
+      end
     end
 
     # @private

data/lib/vcr/cassette/serializers.rb

@@ -2,10 +2,11 @@ module VCR
   class Cassette
     # Keeps track of the cassette serializers in a hash-like object.
     class Serializers
-      autoload :YAML,  'vcr/cassette/serializers/yaml'
-      autoload :Syck,  'vcr/cassette/serializers/syck'
-      autoload :Psych, 'vcr/cassette/serializers/psych'
-      autoload :JSON,  'vcr/cassette/serializers/json'
+      autoload :YAML,       'vcr/cassette/serializers/yaml'
+      autoload :Syck,       'vcr/cassette/serializers/syck'
+      autoload :Psych,      'vcr/cassette/serializers/psych'
+      autoload :JSON,       'vcr/cassette/serializers/json'
+      autoload :Compressed, 'vcr/cassette/serializers/compressed'
 
       # @private
       def initialize
@@ -20,10 +21,11 @@ module VCR
       def [](name)
         @serializers.fetch(name) do |_|
           @serializers[name] = case name
-            when :yaml  then YAML
-            when :syck  then Syck
-            when :psych then Psych
-            when :json  then JSON
+            when :yaml        then YAML
+            when :syck        then Syck
+            when :psych       then Psych
+            when :json        then JSON
+            when :compressed  then Compressed
             else raise ArgumentError.new("The requested VCR cassette serializer (#{name.inspect}) is not registered.")
           end
         end

data/lib/vcr/cassette/serializers/compressed.rb

@@ -0,0 +1,45 @@
+require 'zlib'
+require 'vcr/cassette/serializers'
+
+module VCR
+  class Cassette
+    class Serializers
+      # The compressed serializer. This serializer wraps the YAML serializer
+      # to write compressed cassettes to disk.
+      #
+      # Cassettes containing responses with JSON data often compress at greater
+      # than 10:1. The tradeoff is that cassettes will not diff nicely or be
+      # easily inspectable or editable.
+      #
+      # @see YAML
+      module Compressed
+        extend self
+
+        # The file extension to use for this serializer.
+        #
+        # @return [String] "gz"
+        def file_extension
+          'gz'
+        end
+
+        # Serializes the given hash using YAML and Zlib.
+        #
+        # @param [Hash] hash the object to serialize
+        # @return [String] the compressed cassette data
+        def serialize(hash)
+          string = VCR::Cassette::Serializers::YAML.serialize(hash)
+          Zlib::Deflate.deflate(string)
+        end
+
+        # Deserializes the given compressed cassette data.
+        #
+        # @param [String] string the compressed YAML cassette data
+        # @return [Hash] the deserialized object
+        def deserialize(string)
+          yaml = Zlib::Inflate.inflate(string)
+          VCR::Cassette::Serializers::YAML.deserialize(yaml)
+        end
+      end
+    end
+  end
+end

data/lib/vcr/configuration.rb

@@ -386,23 +386,23 @@ module VCR
     # @see #before_http_request
     # @see #after_http_request
     def around_http_request(*filters, &block)
-      require 'fiber'
-    rescue LoadError
-      raise Errors::NotSupportedError.new \
-        "VCR::Configuration#around_http_request requires fibers, " +
-        "which are not available on your ruby intepreter."
-    else
+      unless VCR.fibers_available?
+        raise Errors::NotSupportedError.new \
+          "VCR::Configuration#around_http_request requires fibers, " +
+          "which are not available on your ruby intepreter."
+      end
+
       fibers = {}
-      hook_allowed, hook_decaration = false, caller.first
+      fiber_errors = {}
+      hook_allowed, hook_declaration = false, caller.first
       before_http_request(*filters) do |request|
         hook_allowed = true
-        fiber = start_new_fiber_for(request, block)
-        fibers[Thread.current] = fiber
+        start_new_fiber_for(request, fibers, fiber_errors, hook_declaration, block)
       end
 
       after_http_request(lambda { hook_allowed }) do |request, response|
         fiber = fibers.delete(Thread.current)
-        resume_fiber(fiber, response, hook_decaration)
+        resume_fiber(fiber, fiber_errors, response, hook_declaration)
       end
     end
 
@@ -506,20 +506,41 @@ module VCR
       raise ArgumentError.new("#{hook.inspect} is not a supported VCR HTTP library hook.")
     end
 
-    def resume_fiber(fiber, response, hook_declaration)
+    def resume_fiber(fiber, fiber_errors, response, hook_declaration)
+      raise fiber_errors[Thread.current] if fiber_errors[Thread.current]
       fiber.resume(response)
-    rescue FiberError
+    rescue FiberError => ex
       raise Errors::AroundHTTPRequestHookError.new \
-        "Your around_http_request hook declared at #{hook_declaration}" +
-        " must call #proceed on the yielded request but did not."
+        "Your around_http_request hook declared at #{hook_declaration}" \
+        " must call #proceed on the yielded request but did not. " \
+        "(actual error: #{ex.class}: #{ex.message})"
     end
 
-    def start_new_fiber_for(request, block)
-      Fiber.new(&block).tap do |fiber|
-        fiber.resume(Request::FiberAware.new(request))
+    def create_fiber_for(fiber_errors, hook_declaration, proc)
+      current_thread = Thread.current
+      Fiber.new do |*args, &block|
+        begin
+          # JRuby Fiber runs in a separate thread, so we need to make this Fiber
+          # use the context of the calling thread
+          VCR.link_context(current_thread, Fiber.current) if RUBY_PLATFORM == 'java'
+          proc.call(*args, &block)
+        rescue StandardError => ex
+          # Fiber errors get swallowed, so we re-raise the error in the parent
+          # thread (see resume_fiber)
+          fiber_errors[current_thread] = ex
+          raise
+        ensure
+          VCR.unlink_context(Fiber.current) if RUBY_PLATFORM == 'java'
+        end
       end
     end
 
+    def start_new_fiber_for(request, fibers, fiber_errors, hook_declaration, proc)
+      fiber = create_fiber_for(fiber_errors, hook_declaration, proc)
+      fibers[Thread.current] = fiber
+      fiber.resume(Request::FiberAware.new(request))
+    end
+
     def tag_filter_from(tag)
       return lambda { true } unless tag
       lambda { |_, cassette| cassette.tags.include?(tag) }

data/lib/vcr/library_hooks/fakeweb.rb

@@ -126,6 +126,7 @@ module VCR
         end
       end
 
+      # @private
       class RecursiveRequestHandler < RequestHandler
         attr_reader :stubbed_response
 

data/lib/vcr/library_hooks/faraday.rb

@@ -10,7 +10,11 @@ module VCR
           super.extend BuilderInstanceExtension
         end
 
-        ::Faraday::Builder.extend self
+        if defined?(::Faraday::RackBuilder)
+          ::Faraday::RackBuilder.extend self
+        else
+          ::Faraday::Builder.extend self
+        end
       end
 
       # @private

data/lib/vcr/middleware/faraday.rb

@@ -45,7 +45,8 @@ module VCR
           VCR.library_hooks.exclusive_hook = :faraday
           super
         ensure
-          invoke_after_request_hook(response_for(env)) unless delay_finishing?
+          response = defined?(@vcr_response) ? @vcr_response : nil
+          invoke_after_request_hook(response) unless delay_finishing?
         end
 
       private
@@ -70,10 +71,7 @@ module VCR
           end
         end
 
-        def response_for(env)
-          response = env[:response]
-          return nil unless response
-
+        def response_for(response)
           VCR::Response.new(
             VCR::ResponseStatus.new(response.status, nil),
             response.headers,
@@ -83,7 +81,9 @@ module VCR
         end
 
         def on_ignored_request
-          app.call(env)
+          response = app.call(env)
+          @vcr_response = response_for(response)
+          response
         end
 
         def on_stubbed_by_vcr_request
@@ -91,6 +91,8 @@ module VCR
           headers.update stubbed_response.headers if stubbed_response.headers
           env.update :status => stubbed_response.status.code, :body => stubbed_response.body
 
+          @vcr_response = stubbed_response
+
           faraday_response = ::Faraday::Response.new
           faraday_response.finish(env)
           env[:response] = faraday_response
@@ -98,9 +100,11 @@ module VCR
 
         def on_recordable_request
           @has_on_complete_hook = true
-          app.call(env).on_complete do |env|
-            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, response_for(env)))
-            invoke_after_request_hook(response_for(env)) if delay_finishing?
+          response = app.call(env)
+          response.on_complete do
+            @vcr_response = response_for(response)
+            VCR.record_http_interaction(VCR::HTTPInteraction.new(vcr_request, @vcr_response))
+            invoke_after_request_hook(@vcr_response) if delay_finishing?
           end
         end
 

data/lib/vcr/test_frameworks/cucumber.rb

@@ -40,11 +40,18 @@ module VCR
           options = original_options.dup
 
           cassette_name = if options.delete(:use_scenario_name)
-            feature = scenario.respond_to?(:scenario_outline) ? scenario.scenario_outline.feature : scenario.feature
-            name = feature.name.split("\n").first
-            name << "/#{scenario.scenario_outline.name}" if scenario.respond_to?(:scenario_outline)
-            name << "/#{scenario.name.split("\n").first}"
-            name
+            if scenario.respond_to?(:outline?) && scenario.outline?
+              ScenarioNameBuilder.new(scenario).cassette_name
+            elsif scenario.respond_to?(:scenario_outline)
+              [ scenario.scenario_outline.feature.name.split("\n").first,
+                scenario.scenario_outline.name,
+                scenario.name.split("\n").first
+              ].join("/")
+            else
+              [ scenario.feature.name.split("\n").first,
+                scenario.name.split("\n").first
+              ].join("/")
+            end
           else
             "cucumber_tags/#{tag_name.gsub(/\A@/, '')}"
           end
@@ -60,5 +67,32 @@ module VCR
       end
     end
     alias :tag :tags
+
+    # Constructs a cassette name from a Cucumber 2 scenario outline
+    # @private
+    class ScenarioNameBuilder
+      def initialize(test_case)
+        @parts = []
+        test_case.describe_source_to self
+      end
+
+      def cassette_name
+        @parts.join("/")
+      end
+
+      def feature(feature)
+        @parts.unshift feature.name
+        self
+      end
+      alias scenario_outline feature
+
+      def scenario(*) self end
+      alias examples_table scenario
+
+      def examples_table_row(row)
+        @parts.unshift "| %s |" % row.values.join(" | ")
+        self
+      end
+    end
   end
 end

data/lib/vcr/version.rb

@@ -10,7 +10,7 @@ module VCR
   #   * `parts` [Array<Integer>] List of the version parts.
   def version
     @version ||= begin
-      string = '2.9.3'
+      string = '3.0.0'
 
       def string.parts
         split('.').map { |p| p.to_i }

data/spec/acceptance/concurrency_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe VCR do
+  def recorded_content_for(name)
+    VCR.cassette_persisters[:file_system]["#{name}.yml"].to_s
+  end
+
+  context 'when used in a multithreaded environment with an around_http_request', :with_monkey_patches => :excon do
+    def preload_yaml_serializer_to_avoid_circular_require_warning_race_condition
+      VCR.cassette_serializers[:yaml]
+    end
+
+    before { preload_yaml_serializer_to_avoid_circular_require_warning_race_condition }
+
+    it 'can use a cassette in an #around_http_request hook', :if => (RUBY_VERSION.to_f > 1.8) do
+      VCR.configure do |vcr|
+        vcr.around_http_request do |req|
+          VCR.use_cassette(req.parsed_uri.path, &req)
+        end
+      end
+
+      threads = 50.times.map do
+        Thread.start do
+          Excon.get "http://localhost:#{VCR::SinatraApp.port}/search?q=thread"
+        end
+      end
+      Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo"
+      threads.each(&:join)
+
+      expect(recorded_content_for("search") +
+             recorded_content_for("foo")).to include("query: thread", "FOO!")
+    end
+  end
+
+  context 'when used in a multithreaded environment with a cassette', :with_monkey_patches => :excon do
+    it 'properly stubs threaded requests' do
+      VCR.use_cassette('/foo') do
+        threads = 50.times.map do
+          Thread.start do
+            Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo"
+          end
+        end
+        threads.each(&:join)
+      end
+
+      expect(
+        recorded_content_for("foo")).to include("FOO!")
+    end
+  end
+end
+

data/spec/{vcr → lib/vcr}/cassette/migrator_spec.rb

@@ -1,5 +1,6 @@
 require 'tmpdir'
 require 'vcr/cassette/migrator'
+require 'yaml'
 
 describe VCR::Cassette::Migrator do
   let(:original_contents) { <<-EOF
@@ -114,13 +115,14 @@ EOF
   end if RUBY_PLATFORM == 'java'
 
   # Use syck on all rubies for consistent results...
-  before(:each) do
-    YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
-  end
-
-  after(:each) do
-    YAML::ENGINE.yamler = 'psych' if defined?(YAML::ENGINE)
-  end
+  around(:each) do |example|
+    YAML::ENGINE.yamler = 'syck'
+    begin
+      example.call
+    ensure
+      YAML::ENGINE.yamler = 'psych'
+    end
+  end if defined?(YAML::ENGINE) && RUBY_VERSION.to_f < 2.0
 
   let(:filemtime) { Time.utc(2011, 5, 4, 12, 30) }
   let(:out_io)    { StringIO.new }
@@ -185,11 +187,10 @@ EOF
 
   context 'with psych' do
     before(:each) do
-      pending "psych not available" unless defined?(YAML::ENGINE)
       YAML::ENGINE.yamler = 'psych'
     end
 
     it_behaves_like "ignoring invalid YAML"
-  end
+  end if defined?(YAML::ENGINE)
 end
 

data/spec/{vcr → lib/vcr}/cassette/serializers_spec.rb

@@ -50,7 +50,7 @@ module VCR
       it_behaves_like "a serializer", :yaml,  "yml",  :lazily_loaded do
         it_behaves_like "encoding error handling", :yaml, ArgumentError do
           let(:string) { "\xFA".force_encoding("UTF-8") }
-          before { ::YAML::ENGINE.yamler = 'psych' }
+          before { ::YAML::ENGINE.yamler = 'psych' if defined?(::YAML::ENGINE) }
         end if ''.respond_to?(:encoding)
       end
 
@@ -66,6 +66,12 @@ module VCR
         end if ''.respond_to?(:encoding)
       end if RUBY_VERSION =~ /1.9/
 
+      it_behaves_like "a serializer", :compressed, "gz",  :lazily_loaded do
+        it_behaves_like "encoding error handling", :compressed, ArgumentError do
+          let(:string) { "\xFA".force_encoding("UTF-8") }
+        end if ''.respond_to?(:encoding)
+      end
+
       it_behaves_like "a serializer", :json,  "json", :lazily_loaded do
         engines = {}
 
@@ -156,7 +162,7 @@ module VCR
           ::YAML::ENGINE.yamler = 'syck'
           serialized = subject[:psych].serialize(problematic_syck_string)
           expect(subject[:psych].deserialize(serialized)).to eq(problematic_syck_string)
-        end if defined?(::Psych)
+        end if defined?(::Psych) && RUBY_VERSION.to_f < 2.0
 
         it 'raises an error if psych cannot be loaded' do
           expect { subject[:psych] }.to raise_error(LoadError)