vcr 3.0.3 → 6.1.0

data/features/test_frameworks/rspec_metadata.feature

@@ -1,150 +0,0 @@
-@with-bundler
-Feature: Usage with RSpec metadata
-
-  VCR provides easy integration with RSpec using metadata. To set this
-  up, call `configure_rspec_metadata!` in your `VCR.configure` block.
-
-  Once you've done that, you can have an example group or example use
-  VCR by passing `:vcr` as an additional argument after the description
-  string. It will set the cassette name based on the example's
-  full description.
-
-  If you need to override the cassette name or options, you can pass a
-  hash (`:vcr => { ... }`).
-
-  Background:
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'spec/cassettes'
-        c.hook_into :webmock
-        c.configure_rspec_metadata!
-      end
-
-      RSpec.configure do |c|
-        # so we can use `:vcr` rather than `:vcr => true`;
-        # in RSpec 3 this will no longer be necessary.
-        c.treat_symbols_as_metadata_keys_with_true_values = true
-      end
-      """
-    And a previously recorded cassette file "spec/cassettes/Group/optionally_raises_an_error.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "5"
-          body: 
-            encoding: UTF-8
-            string: Hello
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario: Use `:vcr` metadata
-    Given a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { "Hello" }
-      end
-
-      def make_http_request
-        Net::HTTP.get_response('localhost', '/', $server.port).body
-      end
-
-      require 'spec_helper'
-
-      describe "VCR example group metadata", :vcr do
-        it 'records an http request' do
-          expect(make_http_request).to eq('Hello')
-        end
-
-        it 'records another http request' do
-          expect(make_http_request).to eq('Hello')
-        end
-
-        context 'in a nested example group' do
-          it 'records another one' do
-            expect(make_http_request).to eq('Hello')
-          end
-        end
-      end
-
-      describe "VCR example metadata" do
-        it 'records an http request', :vcr do
-          expect(make_http_request).to eq('Hello')
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should pass with "4 examples, 0 failures"
-     And the file "spec/cassettes/VCR_example_group_metadata/records_an_http_request.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_group_metadata/records_another_http_request.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_group_metadata/in_a_nested_example_group/records_another_one.yml" should contain "Hello"
-     And the file "spec/cassettes/VCR_example_metadata/records_an_http_request.yml" should contain "Hello"
-
-  Scenario: `:allow_unused_http_interactions => false` causes a failure if there are unused interactions
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "Group", :vcr => { :allow_unused_http_interactions => false } do
-        it 'optionally raises an error' do
-          # don't fail
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should fail with an error like:
-      """
-      There are unused HTTP interactions left in the cassette:
-        - [get http://example.com/foo] => [200 "Hello"]
-      """
-
-  Scenario: `:allow_unused_http_interactions => false` does not raise if the example already failed
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "Group", :vcr => { :allow_unused_http_interactions => false } do
-        it 'optionally raises an error' do
-          raise "boom"
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should fail with "boom"
-     And the output should not contain "There are unused HTTP interactions"
-
-  Scenario: Pass a hash to set the cassette options
-    Given a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      vcr_options = { :cassette_name => "example", :record => :new_episodes }
-      describe "Using an options hash", :vcr => vcr_options do
-        it 'uses the provided cassette name' do
-          expect(VCR.current_cassette.name).to eq("example")
-        end
-
-        it 'sets the given options' do
-          expect(VCR.current_cassette.record_mode).to eq(:new_episodes)
-        end
-      end
-      """
-    When I run `rspec spec/vcr_example_spec.rb`
-    Then it should pass with "2 examples, 0 failures"

data/features/test_frameworks/test_unit.feature

@@ -1,49 +0,0 @@
-Feature: Usage with Test::Unit
-
-  To use VCR with Test::Unit, wrap the body of any test method in
-  `VCR.use_cassette`.
-
-  Scenario: Use `VCR.use_cassette` in a test
-    Given a file named "test/test_server.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { "Hello" }
-      end
-      """
-    Given a file named "test/test_helper.rb" with:
-      """ruby
-      require 'test/test_server' if ENV['SERVER'] == 'true'
-      require 'test/unit'
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'test/fixtures/vcr_cassettes'
-        c.default_cassette_options = {
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-      """
-    And a file named "test/vcr_example_test.rb" with:
-      """ruby
-      require 'test_helper'
-
-      class VCRExampleTest < Test::Unit::TestCase
-        def test_use_vcr
-          VCR.use_cassette('test_unit_example') do
-            response = Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0)
-            assert_equal "Hello", response.body
-          end
-        end
-      end
-      """
-    And the directory "test/fixtures/vcr_cassettes" does not exist
-    When I set the "SERVER" environment variable to "true"
-     And I run `ruby -Itest test/vcr_example_test.rb`
-    Then it should pass with "1 tests, 1 assertions, 0 failures, 0 errors"
-    And the file "test/fixtures/vcr_cassettes/test_unit_example.yml" should contain "Hello"
-
-    # Run again without starting the sinatra server so the response will be replayed
-    When I set the "SERVER" environment variable to "false"
-     And I run `ruby -Itest test/vcr_example_test.rb`
-    Then it should pass with "1 tests, 1 assertions, 0 failures, 0 errors"

data/lib/vcr/extensions/net_http_response.rb

@@ -1,36 +0,0 @@
-module VCR
-  # @private
-  module Net
-    # A Net::HTTP response that has already been read raises an IOError when #read_body
-    # is called with a destination string or block.
-    #
-    # This causes a problem when VCR records a response--it reads the body before yielding
-    # the response, and if the code that is consuming the HTTP requests uses #read_body, it
-    # can cause an error.
-    #
-    # This is a bit of a hack, but it allows a Net::HTTP response to be "re-read"
-    # after it has aleady been read.  This attemps to preserve the behavior of
-    # #read_body, acting just as if it had never been read.
-    # @private
-    module HTTPResponse
-      def self.extended(response)
-        response.instance_variable_set(:@__read_body_previously_called, false)
-      end
-
-      def read_body(dest = nil, &block)
-        return super if @__read_body_previously_called
-        return @body if dest.nil? && block.nil?
-        raise ArgumentError.new("both arg and block given for HTTP method") if dest && block
-
-        if @body
-          dest ||= ::Net::ReadAdapter.new(block)
-          dest << @body
-          @body = dest
-        end
-      ensure
-        # allow subsequent calls to #read_body to proceed as normal, without our hack...
-        @__read_body_previously_called = true
-      end
-    end
-  end
-end

data/lib/vcr/library_hooks/fakeweb.rb

@@ -1,197 +0,0 @@
-require 'vcr/util/version_checker'
-require 'fakeweb'
-require 'net/http'
-require 'vcr/extensions/net_http_response'
-require 'vcr/request_handler'
-require 'set'
-
-VCR::VersionChecker.new('FakeWeb', FakeWeb::VERSION, '1.3.0').check_version!
-
-module VCR
-  class LibraryHooks
-    # @private
-    module FakeWeb
-      # @private
-      class RequestHandler < ::VCR::RequestHandler
-        attr_reader :net_http, :request, :request_body, :response_block
-        def initialize(net_http, request, request_body = nil, &response_block)
-          @net_http, @request, @request_body, @response_block =
-           net_http,  request,  request_body,  response_block
-          @stubbed_response, @vcr_response, @recursing = nil, nil, false
-        end
-
-        def handle
-          super
-        ensure
-          invoke_after_request_hook(@vcr_response) unless @recursing
-        end
-
-      private
-
-        def externally_stubbed?
-          ::FakeWeb.registered_uri?(request_method, uri)
-        end
-
-        def on_externally_stubbed_request
-          # just perform the request--FakeWeb will handle it
-          perform_request(:started)
-        end
-
-        def on_recordable_request
-          perform_request(net_http.started?, :record_interaction)
-        end
-
-        def on_stubbed_by_vcr_request
-          with_exclusive_fakeweb_stub(stubbed_response) do
-            # force it to be considered started since it doesn't
-            # recurse in this case like the others.
-            perform_request(:started)
-          end
-        end
-
-        def on_ignored_request
-          perform_request(net_http.started?)
-        end
-
-        def perform_request(started, record_interaction = false)
-          # Net::HTTP calls #request recursively in certain circumstances.
-          # We only want to record the request when the request is started, as
-          # that is the final time through #request.
-          unless started
-            @recursing = true
-            request.instance_variable_set(:@__vcr_request_handler, recursive_request_handler)
-            return net_http.request_without_vcr(request, request_body, &response_block)
-          end
-
-          net_http.request_without_vcr(request, request_body) do |response|
-            @vcr_response = vcr_response_from(response)
-
-            if record_interaction
-              VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, @vcr_response)
-            end
-
-            response.extend VCR::Net::HTTPResponse # "unwind" the response
-            response_block.call(response) if response_block
-          end
-        end
-
-        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 request_method
-          request.method.downcase.to_sym
-        end
-
-        def vcr_request
-          @vcr_request ||= VCR::Request.new \
-            request_method,
-            uri,
-            (request_body || 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
-
-        def recursive_request_handler
-          @recursive_request_handler ||= RecursiveRequestHandler.new(
-            @after_hook_typed_request.type, @stubbed_response, @vcr_request,
-            @net_http, @request, @request_body, &@response_block
-          )
-        end
-      end
-
-      # @private
-      class RecursiveRequestHandler < RequestHandler
-        attr_reader :stubbed_response
-
-        def initialize(request_type, stubbed_response, vcr_request, *args, &response_block)
-          @request_type, @stubbed_response, @vcr_request =
-           request_type,  stubbed_response,  vcr_request
-          super(*args)
-        end
-
-        def handle
-          set_typed_request_for_after_hook(@request_type)
-          send "on_#{@request_type}_request"
-        ensure
-          invoke_after_request_hook(@vcr_response)
-        end
-
-        def request_type(*args)
-          @request_type
-        end
-      end
-    end
-  end
-end
-
-# @private
-module Net
-  # @private
-  class HTTP
-    unless method_defined?(:request_with_vcr)
-      def request_with_vcr(request, *args, &block)
-        if VCR.turned_on?
-          handler = request.instance_eval do
-            remove_instance_variable(:@__vcr_request_handler) if defined?(@__vcr_request_handler)
-          end || VCR::LibraryHooks::FakeWeb::RequestHandler.new(self, request, *args, &block)
-
-          handler.handle
-        else
-          request_without_vcr(request, *args, &block)
-        end
-      end
-
-      alias request_without_vcr request
-      alias request request_with_vcr
-    end
-  end
-end
-
-# @private
-module FakeWeb
-  class << self
-    # ensure HTTP requests are always allowed; VCR takes care of disallowing
-    # them at the appropriate times in its hook
-    def allow_net_connect_with_vcr?(*args)
-      VCR.turned_on? ? true : allow_net_connect_without_vcr?(*args)
-    end
-
-    alias allow_net_connect_without_vcr? allow_net_connect?
-    alias allow_net_connect? allow_net_connect_with_vcr?
-  end unless respond_to?(:allow_net_connect_with_vcr?)
-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
-  ::Kernel.warn "WARNING: VCR's FakeWeb integration is deprecated and will be removed in VCR 4.0."
-end
-

data/lib/vcr/library_hooks/typhoeus_0.4.rb

@@ -1,103 +0,0 @@
-VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2').check_version!
-
-module VCR
-  class LibraryHooks
-    # @private
-    module Typhoeus
-      # @private
-      class RequestHandler < ::VCR::RequestHandler
-        attr_reader :request
-        def initialize(request)
-          @request = request
-        end
-
-        def vcr_request
-          @vcr_request ||= VCR::Request.new \
-            request.method,
-            request.url,
-            request.body,
-            request.headers
-        end
-
-      private
-
-        def externally_stubbed?
-          ::Typhoeus::Hydra.stubs.detect { |stub| stub.matches?(request) }
-        end
-
-        def set_typed_request_for_after_hook(*args)
-          super
-          request.instance_variable_set(:@__typed_vcr_request, @after_hook_typed_request)
-        end
-
-        def on_unhandled_request
-          invoke_after_request_hook(nil)
-          super
-        end
-
-        def on_stubbed_by_vcr_request
-          ::Typhoeus::Response.new \
-            :http_version   => stubbed_response.http_version,
-            :code           => stubbed_response.status.code,
-            :status_message => stubbed_response.status.message,
-            :headers_hash   => stubbed_response_headers,
-            :body           => stubbed_response.body
-        end
-
-        def stubbed_response_headers
-          @stubbed_response_headers ||= {}.tap do |hash|
-            stubbed_response.headers.each do |key, values|
-              hash[key] = values.size == 1 ? values.first : values
-            end if stubbed_response.headers
-          end
-        end
-      end
-
-      # @private
-      def self.vcr_response_from(response)
-        VCR::Response.new \
-          VCR::ResponseStatus.new(response.code, response.status_message),
-          response.headers_hash,
-          response.body,
-          response.http_version
-      end
-
-      ::Typhoeus::Hydra.after_request_before_on_complete do |request|
-        unless VCR.library_hooks.disabled?(:typhoeus)
-          vcr_response = vcr_response_from(request.response)
-          typed_vcr_request = request.send(:remove_instance_variable, :@__typed_vcr_request)
-
-          unless request.response.mock?
-            http_interaction = VCR::HTTPInteraction.new(typed_vcr_request, vcr_response)
-            VCR.record_http_interaction(http_interaction)
-          end
-
-          VCR.configuration.invoke_hook(:after_http_request, typed_vcr_request, vcr_response)
-        end
-      end
-
-      ::Typhoeus::Hydra.register_stub_finder do |request|
-        VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
-      end
-    end
-  end
-end
-
-# @private
-module Typhoeus
-  class << Hydra
-    # ensure HTTP requests are always allowed; VCR takes care of disallowing
-    # them at the appropriate times in its hook
-    def allow_net_connect_with_vcr?(*args)
-      VCR.turned_on? ? true : allow_net_connect_without_vcr?
-    end
-
-    alias allow_net_connect_without_vcr? allow_net_connect?
-    alias allow_net_connect? allow_net_connect_with_vcr?
-  end unless Hydra.respond_to?(:allow_net_connect_with_vcr?)
-end
-
-VCR.configuration.after_library_hooks_loaded do
-  ::Kernel.warn "WARNING: VCR's Typhoeus 0.4 integration is deprecated and will be removed in VCR 3.0."
-end
-

data/spec/acceptance/concurrency_spec.rb

@@ -1,51 +0,0 @@
-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/acceptance/threading_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe VCR do
-  context 'when used in a multithreaded environment', :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 }
-
-    def recorded_content_for(name)
-      VCR.cassette_persisters[:file_system]["#{name}.yml"].to_s
-    end
-
-    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
-
-      thread = Thread.start do
-        Excon.get "http://localhost:#{VCR::SinatraApp.port}/search?q=thread"
-      end
-
-      Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo",
-        :response_block => Proc.new { thread.join }
-
-      expect(recorded_content_for("search") +
-             recorded_content_for("foo")).to include("query: thread", "FOO!")
-    end
-  end
-end
-