vcr 3.0.2 → 6.0.0

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/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
-

data/spec/fixtures/cassette_spec/1_x_cassette.yml

@@ -1,110 +0,0 @@
---- 
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: http://example.com:80/
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      last-modified: 
-      - Tue, 15 Nov 2005 13:24:10 GMT
-      connection: 
-      - Keep-Alive
-      date: 
-      - Thu, 25 Feb 2010 07:52:38 GMT
-      content-type: 
-      - text/html; charset=UTF-8
-      etag: 
-      - "\"24ec5-1b6-4059a80bfd280\""
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "438"
-      age: 
-      - "3009"
-      accept-ranges: 
-      - bytes
-    body: |
-      <HTML>
-      <HEAD>
-        <TITLE>Example Web Page</TITLE>
-      </HEAD> 
-      <body>  
-      <p>You have reached this web page by typing &quot;example.com&quot;,
-      &quot;example.net&quot;,
-        or &quot;example.org&quot; into your web browser.</p>
-      <p>These domain names are reserved for use in documentation and are not available 
-        for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC 
-        2606</a>, Section 3.</p>
-      </BODY>
-      </HTML>
-
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: http://example.com:80/foo
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 404
-      message: Not Found
-    headers: 
-      connection: 
-      - close
-      content-type: 
-      - text/html; charset=iso-8859-1
-      date: 
-      - Thu, 25 Feb 2010 07:52:38 GMT
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "277"
-    body: |
-      <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
-      <html><head>
-      <title>404 Not Found</title>
-      </head><body>
-      <h1>Not Found</h1>
-      <p>The requested URL /foo was not found on this server.</p>
-      <hr>
-      <address>Apache/2.2.3 (CentOS) Server at example.com Port 80</address>
-      </body></html>
-
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: http://example.com:80/
-    body: 
-    headers: 
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      last-modified: 
-      - Tue, 15 Nov 2005 13:24:10 GMT
-      connection: 
-      - Keep-Alive
-      date: 
-      - Thu, 25 Feb 2010 07:52:38 GMT
-      content-type: 
-      - text/html; charset=UTF-8
-      etag: 
-      - "\"24ec5-1b6-4059a80bfd280\""
-      server: 
-      - Apache/2.2.3 (CentOS)
-      content-length: 
-      - "438"
-      age: 
-      - "3009"
-      accept-ranges: 
-      - bytes
-    body: Another example.com response
-    http_version: "1.1"