vcr 1.11.3 → 2.0.0.beta1

data/lib/vcr/deprecations/cassette.rb

@@ -1,29 +0,0 @@
-module VCR
-  class Cassette
-    def allow_real_http_requests_to?(uri)
-      warn "WARNING: VCR::Cassette#allow_real_http_requests_to? is deprecated and should no longer be used."
-      VCR::Config.uri_should_be_ignored?(uri.to_s)
-    end
-
-  private
-
-    def deprecate_old_cassette_options(options)
-      message = "VCR's :allow_real_http cassette option is deprecated.  Instead, use the ignore_localhost configuration option."
-      if options[:allow_real_http] == :localhost
-        @original_ignored_hosts = VCR::Config.ignored_hosts.dup
-        VCR::Config.ignored_hosts.clear
-        VCR::Config.ignore_hosts(*VCR::LOCALHOST_ALIASES)
-        Kernel.warn "WARNING: #{message}"
-      elsif options[:allow_real_http]
-        raise ArgumentError.new(message)
-      end
-    end
-
-    def restore_ignore_localhost_for_deprecation
-      if defined?(@original_ignored_hosts)
-        VCR::Config.ignored_hosts.clear
-        VCR::Config.ignore_hosts(*@original_ignored_hosts)
-      end
-    end
-  end
-end

data/lib/vcr/deprecations/config.rb

@@ -1,18 +0,0 @@
-module VCR
-  module Config
-    def http_stubbing_library
-      warn "WARNING: `VCR::Config.http_stubbing_library` is deprecated.  Use `VCR::Config.http_stubbing_libraries` instead."
-      @http_stubbing_libraries && @http_stubbing_libraries.first
-    end
-
-    def http_stubbing_library=(library)
-      warn "WARNING: `VCR::Config.http_stubbing_library = #{library.inspect}` is deprecated.  Use `VCR::Config.stub_with #{library.inspect}` instead."
-      stub_with library
-    end
-
-    def ignore_localhost?
-      warn "WARNING: `VCR::Config.ignore_localhost?` is deprecated.  Check the list of ignored hosts using `VCR::Config.ignored_hosts` instead."
-      (VCR::LOCALHOST_ALIASES - ignored_hosts).empty?
-    end
-  end
-end

data/lib/vcr/deprecations/http_stubbing_adapters/common.rb

@@ -1,9 +0,0 @@
-module VCR
-  module HttpStubbingAdapters
-    module Common
-      def ignore_localhost?
-        VCR::Config.ignore_localhost?
-      end
-    end
-  end
-end

data/lib/vcr/deprecations/http_stubbing_adapters/fakeweb.rb

@@ -1,11 +0,0 @@
-module VCR
-  module HttpStubbingAdapters
-    module FakeWeb
-      def self.const_missing(const)
-        return super unless const == :LOCALHOST_REGEX
-        warn "WARNING: `VCR::HttpStubbingAdapters::FakeWeb::LOCALHOST_REGEX` is deprecated."
-        VCR::Regexes.url_regex_for_hosts(VCR::LOCALHOST_ALIASES)
-      end
-    end
-  end
-end

data/lib/vcr/extensions/net_http.rb

@@ -1,32 +0,0 @@
-require 'net/http'
-require 'vcr/extensions/net_http_response'
-
-module Net
-  class HTTP
-    def request_with_vcr(request, body = nil, &block)
-      unless VCR::HttpStubbingAdapters::FakeWeb.enabled?
-        return request_without_vcr(request, body, &block)
-      end
-
-      vcr_request = VCR::Request.from_net_http_request(self, request)
-      response = request_without_vcr(request, body)
-
-      match_attributes = if cass = VCR.current_cassette
-        cass.match_requests_on
-      else
-        VCR::RequestMatcher::DEFAULT_MATCH_ATTRIBUTES
-      end
-
-      if started? && !VCR.http_stubbing_adapter.request_stubbed?(vcr_request, match_attributes)
-        VCR.record_http_interaction VCR::HTTPInteraction.new(vcr_request, VCR::Response.from_net_http_response(response))
-        response.extend VCR::Net::HTTPResponse # "unwind" the response
-      end
-
-      yield response if block_given?
-      response
-    end
-
-    alias request_without_vcr request
-    alias request request_with_vcr
-  end
-end

data/lib/vcr/http_stubbing_adapters/common.rb

@@ -1,202 +0,0 @@
-module VCR
-  module HttpStubbingAdapters
-    autoload :Excon,            'vcr/http_stubbing_adapters/excon'
-    autoload :FakeWeb,          'vcr/http_stubbing_adapters/fakeweb'
-    autoload :Faraday,          'vcr/http_stubbing_adapters/faraday'
-    autoload :MultiObjectProxy, 'vcr/http_stubbing_adapters/multi_object_proxy'
-    autoload :Typhoeus,         'vcr/http_stubbing_adapters/typhoeus'
-    autoload :WebMock,          'vcr/http_stubbing_adapters/webmock'
-
-    class UnsupportedRequestMatchAttributeError < ArgumentError; end
-
-    module Common
-      class << self
-        attr_accessor :exclusively_enabled_adapter
-
-        def add_vcr_info_to_exception_message(exception_klass)
-          exception_klass.class_eval do
-            def initialize(message)
-              super(message + '.  ' + VCR::HttpStubbingAdapters::Common::RECORDING_INSTRUCTIONS)
-            end
-          end
-        end
-
-        def adapters
-          @adapters ||= []
-        end
-
-        def included(adapter)
-          adapters << adapter
-        end
-      end
-
-      RECORDING_INSTRUCTIONS = "You can use VCR to automatically record this request and replay it later.  " +
-                               "For more details, visit the VCR documentation at: http://relishapp.com/myronmarston/vcr/v/#{VCR.version.gsub('.', '-')}"
-
-      def enabled?
-        [nil, self].include? VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter
-      end
-
-      def after_adapters_loaded
-        # no-op
-      end
-
-      def exclusively_enabled
-        VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter = self
-
-        begin
-          yield
-        ensure
-          VCR::HttpStubbingAdapters::Common.exclusively_enabled_adapter = nil
-        end
-      end
-
-      def check_version!
-        case compare_version
-          when :too_low
-            raise "You are using #{library_name} #{version}.  VCR requires version #{version_requirement}."
-          when :too_high
-            warn "You are using #{library_name} #{version}.  VCR is known to work with #{library_name} #{version_requirement}.  It may not work with this version."
-        end
-      end
-
-      def library_name
-        @library_name ||= self.to_s.split('::').last
-      end
-
-      def set_http_connections_allowed_to_default
-        self.http_connections_allowed = VCR::Config.allow_http_connections_when_no_cassette?
-      end
-
-      def raise_no_checkpoint_error(cassette)
-        raise ArgumentError.new("No checkpoint for #{cassette.inspect} could be found")
-      end
-
-      attr_writer :http_connections_allowed
-
-      def http_connections_allowed?
-        defined?(@http_connections_allowed) && !!@http_connections_allowed
-      end
-
-      def ignored_hosts=(hosts)
-        @ignored_hosts = hosts
-      end
-
-      def uri_should_be_ignored?(uri)
-        uri = URI.parse(uri) unless uri.respond_to?(:host)
-        ignored_hosts.include?(uri.host)
-      end
-
-      def stub_requests(http_interactions, match_attributes)
-        match_attributes_stack << match_attributes
-        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
-          request_matcher = request_matcher_with_normalized_uri(request_matcher)
-          queue = stub_queues[request_matcher]
-          responses.each { |res| queue << res }
-        end
-      end
-
-      def create_stubs_checkpoint(cassette)
-        checkpoints[cassette] = stub_queue_dup
-      end
-
-      def restore_stubs_checkpoint(cassette)
-        match_attributes_stack.pop
-        @stub_queues = checkpoints.delete(cassette) || raise_no_checkpoint_error(cassette)
-      end
-
-      def stubbed_response_for(request)
-        return nil unless match_attributes_stack.any?
-        request_matcher = request.matcher(match_attributes_stack.last)
-        queue = stub_queues[request_matcher]
-        return queue.shift if queue.size > 1
-        queue.first
-      end
-
-      def reset!
-        instance_variables.each do |ivar|
-          remove_instance_variable(ivar)
-        end
-      end
-
-      private
-
-      def ignored_hosts
-        @ignored_hosts ||= []
-      end
-
-      def checkpoints
-        @checkpoints ||= {}
-      end
-
-      def stub_queues
-        @stub_queues ||= hash_of_arrays
-      end
-
-      def match_attributes_stack
-        @match_attributes_stack ||= []
-      end
-
-      def stub_queue_dup
-        dup = hash_of_arrays
-
-        stub_queues.each do |k, v|
-          dup[k] = v.dup
-        end
-
-        dup
-      end
-
-      def hash_of_arrays
-        Hash.new { |h, k| h[k] = [] }
-      end
-
-      def compare_version
-        major,     minor,     patch     = parse_version(version)
-        min_major, min_minor, min_patch = parse_version(self::MINIMUM_VERSION)
-        max_major, max_minor            = parse_version(self::MAXIMUM_VERSION)
-
-        case
-          when major < min_major; :too_low
-          when major > max_major; :too_high
-          when minor < min_minor; :too_low
-          when minor > max_minor; :too_high
-          when patch < min_patch; :too_low
-        end
-      end
-
-      def version_requirement
-        max_major, max_minor = parse_version(self::MAXIMUM_VERSION)
-        ">= #{self::MINIMUM_VERSION}, < #{max_major}.#{max_minor + 1}"
-      end
-
-      def parse_version(version)
-        version.split('.').map { |v| v.to_i }
-      end
-
-      def grouped_responses(http_interactions, match_attributes)
-        responses = Hash.new { |h,k| h[k] = [] }
-
-        http_interactions.each do |i|
-          responses[i.request.matcher(match_attributes)] << i.response
-        end
-
-        responses
-      end
-
-      def normalize_uri(uri)
-        uri # adapters can override this
-      end
-
-      def request_matcher_with_normalized_uri(matcher)
-        normalized_uri = normalize_uri(matcher.request.uri)
-        return matcher unless matcher.request.uri != normalized_uri
-
-        request = matcher.request.dup
-        request.uri = normalized_uri
-
-        RequestMatcher.new(request, matcher.match_attributes)
-      end
-    end
-  end
-end

data/lib/vcr/http_stubbing_adapters/excon.rb

@@ -1,178 +0,0 @@
-require 'excon'
-
-module VCR
-  module HttpStubbingAdapters
-    module Excon
-      include VCR::HttpStubbingAdapters::Common
-      extend self
-
-      class HttpConnectionNotAllowedError < StandardError; end
-
-      MINIMUM_VERSION = '0.6.5'
-      MAXIMUM_VERSION = '0.6'
-
-      private
-
-      def version
-        ::Excon::VERSION
-      end
-
-      class RequestHandler
-        attr_reader :params
-        def initialize(params)
-          @params = params
-        end
-
-        def handle
-          case
-            when request_should_be_ignored?
-              perform_real_request
-            when stubbed_response
-              stubbed_response
-            when http_connections_allowed?
-              record_interaction
-            else
-              raise_connections_disabled_error
-          end
-        end
-
-        private
-
-          def request_should_be_ignored?
-            VCR::HttpStubbingAdapters::Excon.uri_should_be_ignored?(uri)
-          end
-
-          def stubbed_response
-            @stubbed_response ||= begin
-              if stubbed_response = VCR::HttpStubbingAdapters::Excon.stubbed_response_for(vcr_request)
-                {
-                  :body     => stubbed_response.body,
-                  :headers  => normalized_headers(stubbed_response.headers || {}),
-                  :status   => stubbed_response.status.code
-                }
-              end
-            end
-          end
-
-          def http_connections_allowed?
-            VCR::HttpStubbingAdapters::Excon.http_connections_allowed?
-          end
-
-          def response_from_excon_error(error)
-            if error.respond_to?(:response)
-              error.response
-            elsif error.respond_to?(:socket_error)
-              response_from_excon_error(error.socket_error)
-            else
-              warn "WARNING: VCR could not extract a response from Excon error (#{error.inspect})"
-            end
-          end
-
-          def perform_real_request
-            connection = ::Excon.new(uri)
-
-            response = begin
-              connection.request(params.merge(:mock => false))
-            rescue ::Excon::Errors::Error => e
-              yield response_from_excon_error(e) if block_given?
-              raise e
-            end
-
-            yield response if block_given?
-
-            response.attributes
-          end
-
-          def record_interaction
-            perform_real_request do |response|
-              if VCR::HttpStubbingAdapters::Excon.enabled?
-                http_interaction = http_interaction_for(response)
-                VCR.record_http_interaction(http_interaction)
-              end
-            end
-          end
-
-          def uri
-            @uri ||= "#{params[:scheme]}://#{params[:host]}:#{params[:port]}#{params[:path]}#{query}"
-          end
-
-          def query
-            @query ||= case params[:query]
-              when String
-                "?#{params[:query]}"
-              when Hash
-                qry = '?'
-                for key, values in params[:query]
-                  if values.nil?
-                    qry << key.to_s << '&'
-                  else
-                    for value in [*values]
-                      qry << key.to_s << '=' << CGI.escape(value.to_s) << '&'
-                    end
-                  end
-                end
-                qry.chop! # remove trailing '&'
-              else
-                ''
-            end
-          end
-
-          def http_interaction_for(response)
-            VCR::HTTPInteraction.new \
-              vcr_request,
-              vcr_response(response)
-          end
-
-          def vcr_request
-            @vcr_request ||= begin
-              headers = params[:headers].dup
-              headers.delete("Host")
-
-              VCR::Request.new \
-                params[:method],
-                uri,
-                params[:body],
-                headers
-            end
-          end
-
-          def vcr_response(response)
-            VCR::Response.new \
-              VCR::ResponseStatus.new(response.status, nil),
-              response.headers,
-              response.body,
-              nil
-          end
-
-          def normalized_headers(headers)
-            normalized = {}
-            headers.each do |k, v|
-              v = v.join(', ') if v.respond_to?(:join)
-              normalized[normalize_header_key(k)] = v
-            end
-            normalized
-          end
-
-          def normalize_header_key(key)
-            key.split('-').               # 'user-agent' => %w(user agent)
-              each { |w| w.capitalize! }. # => %w(User Agent)
-              join('-')
-          end
-
-          def raise_connections_disabled_error
-            raise HttpConnectionNotAllowedError.new(
-              "Real HTTP connections are disabled. Request: #{params[:method]} #{uri}"
-            )
-          end
-
-          ::Excon.stub({}) do |params|
-            self.new(params).handle
-          end
-      end
-
-    end
-  end
-end
-
-Excon.mock = true
-VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(VCR::HttpStubbingAdapters::Excon::HttpConnectionNotAllowedError)