vcr 1.11.3 → 2.0.0.beta1

data/lib/vcr/http_stubbing_adapters/fakeweb.rb

@@ -1,107 +0,0 @@
-require 'fakeweb'
-require 'vcr/deprecations/http_stubbing_adapters/fakeweb'
-require 'vcr/extensions/net_http'
-
-module VCR
-  module HttpStubbingAdapters
-    module FakeWeb
-      include VCR::HttpStubbingAdapters::Common
-      extend self
-
-      UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES = [:body, :headers]
-
-      MINIMUM_VERSION = '1.3.0'
-      MAXIMUM_VERSION = '1.3'
-
-      def http_connections_allowed=(value)
-        @http_connections_allowed = value
-        update_fakeweb_allow_net_connect
-      end
-
-      def http_connections_allowed?
-        !!::FakeWeb.allow_net_connect?("http://some.url/besides/localhost")
-      end
-
-      def ignored_hosts=(hosts)
-        @ignored_hosts = hosts
-        update_fakeweb_allow_net_connect
-      end
-
-      def stub_requests(http_interactions, match_attributes)
-        validate_match_attributes(match_attributes)
-
-        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
-          ::FakeWeb.register_uri(
-            request_matcher.method || :any,
-            request_matcher.uri,
-            responses.map{ |r| response_hash(r) }
-          )
-        end
-      end
-
-      def create_stubs_checkpoint(cassette)
-        checkpoints[cassette] = ::FakeWeb::Registry.instance.uri_map.dup
-      end
-
-      def restore_stubs_checkpoint(cassette)
-        ::FakeWeb::Registry.instance.uri_map = checkpoints.delete(cassette) || raise_no_checkpoint_error(cassette)
-      end
-
-      def request_stubbed?(request, match_attributes)
-        validate_match_attributes(match_attributes)
-        !!::FakeWeb.registered_uri?(request.method, request.uri)
-      end
-
-      def request_uri(net_http, request)
-        ::FakeWeb::Utility.request_uri_as_string(net_http, request)
-      end
-
-      private
-
-      def ignored_hosts
-        @ignored_hosts ||= []
-      end
-
-      def version
-        ::FakeWeb::VERSION
-      end
-
-      def update_fakeweb_allow_net_connect
-        ::FakeWeb.allow_net_connect = if @http_connections_allowed
-          true
-        elsif ignored_hosts.any?
-          VCR::Regexes.url_regex_for_hosts(ignored_hosts)
-        else
-          false
-        end
-      end
-
-      def checkpoints
-        @checkpoints ||= {}
-      end
-
-      def response_hash(response)
-        (response.headers || {}).merge(
-          :body   => response.body,
-          :status => [response.status.code.to_s, response.status.message]
-        )
-      end
-
-      def validate_match_attributes(match_attributes)
-        invalid_attributes = match_attributes & UNSUPPORTED_REQUEST_MATCH_ATTRIBUTES
-        if invalid_attributes.size > 0
-          raise UnsupportedRequestMatchAttributeError.new("FakeWeb does not support matching requests on #{invalid_attributes.join(' or ')}")
-        end
-      end
-
-      def initialize_ivars
-        @http_connections_allowed = nil
-      end
-
-      initialize_ivars # to avoid warnings
-    end
-  end
-end
-
-VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(FakeWeb::NetConnectNotAllowedError)
-

data/lib/vcr/http_stubbing_adapters/faraday.rb

@@ -1,26 +0,0 @@
-require 'faraday'
-
-module VCR
-  module HttpStubbingAdapters
-    module Faraday
-      include Common
-      extend self
-
-      MINIMUM_VERSION = '0.6.0'
-      MAXIMUM_VERSION = '0.6'
-
-      private
-
-      def version
-        ::Faraday::VERSION
-      end
-
-      def normalize_uri(uri)
-        # faraday normalizes +'s to %20's
-        uri.gsub('+', '%20')
-      end
-    end
-  end
-end
-
-VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(VCR::Middleware::Faraday::HttpConnectionNotAllowedError)

data/lib/vcr/http_stubbing_adapters/multi_object_proxy.rb

@@ -1,43 +0,0 @@
-module VCR
-  module HttpStubbingAdapters
-    class MultiObjectProxy < VCR::BasicObject
-
-      def self.for(*objects)
-        return objects.first if objects.size == 1
-        new(*objects)
-      end
-
-      attr_reader :proxied_objects
-
-      def initialize(*objects)
-        ::Kernel.raise ::ArgumentError.new("You must pass at least one object to proxy to") if objects.empty?
-        ::Kernel.raise ::ArgumentError.new("Cannot proxy to nil") if objects.any? { |o| o.nil? }
-
-        @proxied_objects = objects
-      end
-
-      def respond_to?(message)
-        proxied_objects.any? { |o| o.respond_to?(message) }
-      end
-
-      private
-
-        def method_missing(name, *args)
-          responding_proxied_objects = proxied_objects.select { |o| o.respond_to?(name) }
-          return super if responding_proxied_objects.empty?
-
-          uniq_return_vals = responding_proxied_objects.map { |o| o.__send__(name, *args) }.uniq
-
-          return nil unless method_return_val_important?(name)
-          return uniq_return_vals.first if uniq_return_vals.size == 1
-
-          ::Kernel.raise "The proxied objects returned different values for calls to #{name}: #{uniq_return_vals.inspect}"
-        end
-
-        def method_return_val_important?(method_name)
-          method_name == :request_uri || method_name.to_s =~ /\?$/
-        end
-    end
-  end
-end
-

data/lib/vcr/http_stubbing_adapters/typhoeus.rb

@@ -1,115 +0,0 @@
-require 'typhoeus'
-
-module VCR
-  module HttpStubbingAdapters
-    module Typhoeus
-      include VCR::HttpStubbingAdapters::Common
-      extend self
-
-      MINIMUM_VERSION = '0.2.1'
-      MAXIMUM_VERSION = '0.2'
-
-      def http_connections_allowed=(value)
-        ::Typhoeus::Hydra.allow_net_connect = value
-      end
-
-      def http_connections_allowed?
-        !!::Typhoeus::Hydra.allow_net_connect?
-      end
-
-      def ignored_hosts=(hosts)
-        ::Typhoeus::Hydra.ignore_hosts = hosts
-      end
-
-      def stub_requests(http_interactions, match_attributes)
-        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
-          ::Typhoeus::Hydra.stub(
-            request_matcher.method || :any,
-            request_matcher.uri,
-            request_hash(request_matcher)
-          ).and_return(
-            responses.map do |response|
-              ::Typhoeus::Response.new(
-                :code         => response.status.code,
-                :body         => response.body,
-                :headers_hash => normalized_response_headers(response)
-              )
-            end
-          )
-        end
-      end
-
-      def create_stubs_checkpoint(cassette)
-        checkpoints[cassette] = ::Typhoeus::Hydra.stubs.dup
-      end
-
-      def restore_stubs_checkpoint(cassette)
-        ::Typhoeus::Hydra.stubs = checkpoints.delete(cassette) || raise_no_checkpoint_error(cassette)
-      end
-
-      def after_adapters_loaded
-        # ensure WebMock's Typhoeus adapter does not conflict with us here
-        # (i.e. to double record requests or whatever).
-        if defined?(::WebMock::HttpLibAdapters::TyphoeusAdapter)
-          ::WebMock::HttpLibAdapters::TyphoeusAdapter.disable!
-        end
-      end
-
-      private
-
-      def version
-        ::Typhoeus::VERSION
-      end
-
-      def checkpoints
-        @checkpoints ||= {}
-      end
-
-      def request_hash(request_matcher)
-        hash = {}
-
-        hash[:body]    = request_matcher.body    if request_matcher.match_requests_on?(:body)
-        hash[:headers] = request_matcher.headers if request_matcher.match_requests_on?(:headers)
-
-        hash
-      end
-
-      def normalized_response_headers(response)
-        hash = {}
-
-        response.headers.each do |key, values|
-          hash[key] = values.size == 1 ? values.first : values
-        end if response.headers
-
-        hash
-      end
-    end
-  end
-end
-
-Typhoeus::Hydra.after_request_before_on_complete do |request|
-  if VCR::HttpStubbingAdapters::Typhoeus.enabled? && !request.response.mock?
-    http_interaction = VCR::HTTPInteraction.new(
-      VCR::Request.new(
-        request.method,
-        request.url,
-        request.body,
-        request.headers
-      ),
-      VCR::Response.new(
-        VCR::ResponseStatus.new(
-          request.response.code,
-          request.response.status_message
-        ),
-        request.response.headers_hash,
-        request.response.body,
-        request.response.http_version
-      )
-    )
-
-    VCR.record_http_interaction(http_interaction)
-  end
-end
-
-VCR::HttpStubbingAdapters::Common.add_vcr_info_to_exception_message(Typhoeus::Hydra::NetConnectNotAllowedError)
-

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -1,120 +0,0 @@
-require 'webmock'
-
-module VCR
-  module HttpStubbingAdapters
-    module WebMock
-      include VCR::HttpStubbingAdapters::Common
-      extend self
-
-      MINIMUM_VERSION = '1.7.0'
-      MAXIMUM_VERSION = '1.7'
-
-      def http_connections_allowed=(value)
-        @http_connections_allowed = value
-        update_webmock_allow_net_connect
-      end
-
-      def http_connections_allowed?
-        !!::WebMock::Config.instance.allow_net_connect
-      end
-
-      def ignored_hosts=(hosts)
-        @ignored_hosts = hosts
-        update_webmock_allow_net_connect
-      end
-
-      def stub_requests(http_interactions, match_attributes)
-        grouped_responses(http_interactions, match_attributes).each do |request_matcher, responses|
-          stub = ::WebMock.stub_request(request_matcher.method || :any, request_matcher.uri)
-
-          with_hash = request_signature_hash(request_matcher)
-          stub = stub.with(with_hash) if with_hash.size > 0
-
-          stub.to_return(responses.map{ |r| response_hash(r) })
-        end
-      end
-
-      def create_stubs_checkpoint(cassette)
-        checkpoints[cassette] = ::WebMock::StubRegistry.instance.request_stubs.dup
-      end
-
-      def restore_stubs_checkpoint(cassette)
-        ::WebMock::StubRegistry.instance.request_stubs = checkpoints.delete(cassette) || raise_no_checkpoint_error(cassette)
-      end
-
-      private
-
-      def version
-        ::WebMock.version
-      end
-
-      def ignored_hosts
-        @ignored_hosts ||= []
-      end
-
-      def update_webmock_allow_net_connect
-        if @http_connections_allowed
-          ::WebMock.allow_net_connect!
-        else
-          ::WebMock.disable_net_connect!(:allow => ignored_hosts)
-        end
-      end
-
-      def request_signature_hash(request_matcher)
-        signature = {}
-        signature[:body]    = request_matcher.body    if request_matcher.match_requests_on?(:body)
-        signature[:headers] = request_matcher.headers if request_matcher.match_requests_on?(:headers)
-        signature
-      end
-
-      def response_hash(response)
-        {
-          :body    => response.body,
-          :status  => [response.status.code.to_i, response.status.message],
-          :headers => response.headers
-        }
-      end
-
-      def checkpoints
-        @checkpoints ||= {}
-      end
-
-      def initialize_ivars
-        @http_connections_allowed = nil
-      end
-
-      initialize_ivars # to avoid warnings
-    end
-  end
-end
-
-WebMock.after_request(:real_requests_only => true) do |request, response|
-  if VCR::HttpStubbingAdapters::WebMock.enabled?
-    http_interaction = VCR::HTTPInteraction.new(
-      VCR::Request.new(
-        request.method,
-        request.uri.to_s,
-        request.body,
-        request.headers
-      ),
-      VCR::Response.new(
-        VCR::ResponseStatus.new(
-          response.status.first,
-          response.status.last
-        ),
-        response.headers,
-        response.body,
-        '1.1'
-      )
-    )
-
-    VCR.record_http_interaction(http_interaction)
-  end
-end
-
-WebMock::NetConnectNotAllowedError.class_eval do
-  undef stubbing_instructions
-  def stubbing_instructions(*args)
-    '.  ' + VCR::HttpStubbingAdapters::Common::RECORDING_INSTRUCTIONS
-  end
-end

data/lib/vcr/middleware/cassette_arguments.rb

@@ -1,19 +0,0 @@
-module VCR
-  module Middleware
-    class CassetteArguments
-      def initialize
-        @name    = nil
-        @options = {}
-      end
-
-      def name(name = nil)
-        @name = name if name
-        @name
-      end
-
-      def options(options = {})
-        @options.merge!(options)
-      end
-    end
-  end
-end

data/lib/vcr/middleware/common.rb

@@ -1,20 +0,0 @@
-module VCR
-  module Middleware
-    module Common
-      include VCR::VariableArgsBlockCaller
-
-      def initialize(app, &block)
-        raise ArgumentError.new("You must provide a block to set the cassette options") unless block
-        @app, @cassette_arguments_block = app, block
-      end
-
-      private
-
-        def cassette_arguments(env)
-          arguments = CassetteArguments.new
-          call_block(@cassette_arguments_block, arguments, env)
-          [arguments.name, arguments.options]
-        end
-    end
-  end
-end