vcr 1.5.1 → 1.6.0

data/lib/vcr/http_stubbing_adapters/faraday.rb

@@ -9,14 +9,19 @@ module VCR
       MINIMUM_VERSION = '0.5.3'
       MAXIMUM_VERSION = '0.5'
 
-      attr_writer :http_connections_allowed, :ignore_localhost
+      attr_writer :http_connections_allowed
 
       def http_connections_allowed?
         !!@http_connections_allowed
       end
 
-      def ignore_localhost?
-        !!@ignore_localhost
+      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)
@@ -52,6 +57,10 @@ module VCR
           ::Faraday::VERSION
         end
 
+        def ignored_hosts
+          @ignored_hosts ||= []
+        end
+
         def checkpoints
           @checkpoints ||= {}
         end

data/lib/vcr/http_stubbing_adapters/typhoeus.rb

@@ -6,7 +6,7 @@ module VCR
       include VCR::HttpStubbingAdapters::Common
       extend self
 
-      MINIMUM_VERSION = '0.2.0'
+      MINIMUM_VERSION = '0.2.1'
       MAXIMUM_VERSION = '0.2'
 
       def http_connections_allowed=(value)
@@ -17,12 +17,8 @@ module VCR
         !!::Typhoeus::Hydra.allow_net_connect?
       end
 
-      def ignore_localhost=(value)
-        ::Typhoeus::Hydra.ignore_localhost = value
-      end
-
-      def ignore_localhost?
-        !!::Typhoeus::Hydra.ignore_localhost?
+      def ignored_hosts=(hosts)
+        ::Typhoeus::Hydra.ignore_hosts = hosts
       end
 
       def stub_requests(http_interactions, match_attributes)

data/lib/vcr/http_stubbing_adapters/webmock.rb

@@ -10,19 +10,17 @@ module VCR
       MAXIMUM_VERSION = '1.6'
 
       def http_connections_allowed=(value)
-        ::WebMock::Config.instance.allow_net_connect = value
+        @http_connections_allowed = value
+        update_webmock_allow_net_connect
       end
 
       def http_connections_allowed?
         !!::WebMock::Config.instance.allow_net_connect
       end
 
-      def ignore_localhost=(value)
-        ::WebMock::Config.instance.allow_localhost = value
-      end
-
-      def ignore_localhost?
-        !!::WebMock::Config.instance.allow_localhost
+      def ignored_hosts=(hosts)
+        @ignored_hosts = hosts
+        update_webmock_allow_net_connect
       end
 
       def stub_requests(http_interactions, match_attributes)
@@ -50,6 +48,18 @@ module VCR
         ::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)

data/lib/vcr/middleware/faraday.rb

@@ -13,7 +13,7 @@ module VCR
             request = request_for(env)
             request_matcher = request.matcher(cassette.match_requests_on)
 
-            if VCR::HttpStubbingAdapters::Faraday.ignore_localhost? && VCR::LOCALHOST_ALIASES.include?(URI.parse(request.uri).host)
+            if VCR::HttpStubbingAdapters::Faraday.uri_should_be_ignored?(request.uri)
               @app.call(env)
             elsif response = VCR::HttpStubbingAdapters::Faraday.stubbed_response_for(request_matcher)
               env.update(

data/lib/vcr/request_matcher.rb

@@ -20,21 +20,21 @@ module VCR
       # for two sets of the same elements unless they are ordered
       # the same, so we sort the attributes here.
       attributes = attributes.sort { |a, b| a.to_s <=> b.to_s }
-      @match_attributes = Set.new(attributes)
+      @match_attributes = set(attributes)
     end
 
     def uri
       return request.uri unless request.uri.is_a?(String)
       uri_matchers = match_attributes.to_a & [:uri, :host, :path]
 
-      case Set.new(uri_matchers)
-        when Set.new then /.*/
-        when Set.new([:uri]) then request.uri
-        when Set.new([:host]) then %r{\Ahttps?://((\w+:)?\w+@)?#{Regexp.escape(URI(request.uri).host)}(:\d+)?/}i
-        when Set.new([:path]) then %r{\Ahttps?://[^/]+#{Regexp.escape(URI(request.uri).path)}/?(\?.*)?\z}i
-        when Set.new([:host, :path])
+      case set(uri_matchers)
+        when set then /.*/
+        when set(:uri) then request.uri
+        when set(:host) then VCR::Regexes.url_regex_for_hosts([URI(request.uri).host])
+        when set(:path) then VCR::Regexes.url_regex_for_path(URI(request.uri).path)
+        when set(:host, :path)
           uri = URI(request.uri)
-          %r{\Ahttps?://((\w+:)?\w+@)?#{Regexp.escape(uri.host)}(:\d+)?#{Regexp.escape(uri.path)}/?(\?.*)?\z}i
+          VCR::Regexes.url_regex_for_host_and_path(uri.host, uri.path)
         else raise ArgumentError.new("match_attributes cannot include #{uri_matchers.join(' and ')}")
       end
     end
@@ -74,6 +74,10 @@ module VCR
 
     private
 
+      def set(*elements)
+        Set.new(elements.flatten)
+      end
+
       def sorted_header_array
         header_hash = headers
         return header_hash unless header_hash.is_a?(Hash)

data/lib/vcr/structs/http_interaction.rb

@@ -0,0 +1,16 @@
+require 'forwardable'
+
+module VCR
+  class HTTPInteraction < Struct.new(:request, :response)
+    extend ::Forwardable
+    def_delegators :request, :uri, :method
+
+    def ignore!
+      @ignored = true
+    end
+
+    def ignored?
+      @ignored
+    end
+  end
+end

data/lib/vcr/structs/normalizers/body.rb

@@ -0,0 +1,24 @@
+module VCR
+  module Normalizers
+    module Body
+      def initialize(*args)
+        super
+        normalize_body
+      end
+
+      private
+
+      def normalize_body
+        # Ensure that the body is a raw string, in case the string instance
+        # has been subclassed or extended with additional instance variables
+        # or attributes, so that it is serialized to YAML as a raw string.
+        # This is needed for rest-client.  See this ticket for more info:
+        # http://github.com/myronmarston/vcr/issues/4
+        self.body = case body
+          when nil, ''; nil
+          else String.new(body)
+        end
+      end
+    end
+  end
+end

data/lib/vcr/structs/normalizers/header.rb

@@ -0,0 +1,56 @@
+module VCR
+  module Normalizers
+    module Header
+      # These headers get added by the various HTTP clients automatically,
+      # and we don't care about them.  We store the headers for the purposes
+      # of request matching, and we only care to match on headers users
+      # explicitly set.
+      HEADERS_TO_SKIP = {
+        'connection' => %w[ close Keep-Alive ],
+        'accept'     => %w[ */* ],
+        'expect'     => [''],
+        'user-agent' => ["Typhoeus - http://github.com/dbalatero/typhoeus/tree/master", 'Ruby']
+      }
+
+      def initialize(*args)
+        super
+        normalize_headers
+      end
+
+      private
+
+      def important_header_values(k, values)
+        skip_values = HEADERS_TO_SKIP[k] || []
+        values - skip_values
+      end
+
+      def normalize_headers
+        new_headers = {}
+
+        headers.each do |k, v|
+          k = k.downcase
+
+          val_array = case v
+            when Array then v
+            when nil then []
+            else [v]
+          end
+
+          important_vals = important_header_values(k, val_array)
+          next unless important_vals.size > 0
+
+          # Ensure the values are raw strings.
+          # Apparently for Paperclip uploads to S3, headers
+          # get serialized with some extra stuff which leads
+          # to a seg fault. See this issue for more info:
+          # https://github.com/myronmarston/vcr/issues#issue/39
+          string_vals = important_vals.map { |v| String.new(v) }
+
+          new_headers[k] = string_vals
+        end if headers
+
+        self.headers = new_headers.empty? ? nil : new_headers
+      end
+    end
+  end
+end

data/lib/vcr/structs/normalizers/status_message.rb

@@ -0,0 +1,17 @@
+module VCR
+  module Normalizers
+    module StatusMessage
+      def initialize(*args)
+        super
+        normalize_status_message
+      end
+
+      private
+
+      def normalize_status_message
+        self.message = message.strip if message
+        self.message = nil if message == ''
+      end
+    end
+  end
+end

data/lib/vcr/structs/normalizers/uri.rb

@@ -0,0 +1,34 @@
+module VCR
+  module Normalizers
+    module URI
+      DEFAULT_PORTS = {
+        'http'  => 80,
+        'https' => 443
+      }
+
+      def initialize(*args)
+        super
+        normalize_uri
+      end
+
+      private
+
+      def normalize_uri
+        u = begin
+          ::URI.parse(uri)
+        rescue ::URI::InvalidURIError
+          return
+        end
+
+        u.port ||= DEFAULT_PORTS[u.scheme]
+
+        # URI#to_s only includes the port if it's not the default
+        # but we want to always include it (since FakeWeb/WebMock
+        # urls have always included it).  We force it to be included
+        # here by redefining default_port so that URI#to_s will include it.
+        def u.default_port; nil; end
+        self.uri = u.to_s
+      end
+    end
+  end
+end

data/lib/vcr/structs/request.rb

@@ -0,0 +1,20 @@
+module VCR
+  class Request < Struct.new(:method, :uri, :body, :headers)
+    include Normalizers::Header
+    include Normalizers::URI
+    include Normalizers::Body
+
+    def self.from_net_http_request(net_http, request)
+      new(
+        request.method.downcase.to_sym,
+        VCR.http_stubbing_adapter.request_uri(net_http, request),
+        request.body,
+        request.to_hash
+      )
+    end
+
+    def matcher(match_attributes)
+      RequestMatcher.new(self, match_attributes)
+    end
+  end
+end

data/lib/vcr/structs/response.rb

@@ -0,0 +1,16 @@
+module VCR
+  class Response < Struct.new(:status, :headers, :body, :http_version)
+    include Normalizers::Header
+    include Normalizers::Body
+
+    def self.from_net_http_response(response)
+      new(
+        ResponseStatus.from_net_http_response(response),
+        response.to_hash,
+        response.body,
+        response.http_version
+      )
+    end
+  end
+end
+

data/lib/vcr/structs/response_status.rb

@@ -0,0 +1,9 @@
+module VCR
+  class ResponseStatus < Struct.new(:code, :message)
+    include Normalizers::StatusMessage
+
+    def self.from_net_http_response(response)
+      new(response.code.to_i, response.message)
+    end
+  end
+end

data/lib/vcr/util/regexes.rb

@@ -0,0 +1,37 @@
+module VCR
+  module Regexes
+    extend self
+
+    PROTOCOL = '\Ahttps?://'
+    CREDENTIALS = '((\w+:)?\w+@)?'
+    PORT = '(:\d+)?'
+    THE_REST = '/?(\?.*)?\z'
+
+    @@url_host_regexes = Hash.new do |hash, hosts|
+      hash[hosts] = begin
+        host_regex = hosts.map { |h| Regexp.escape(h) }.join('|')
+        %r|#{PROTOCOL}#{CREDENTIALS}(#{host_regex})#{PORT}/|i
+      end
+    end
+
+    def url_regex_for_hosts(hosts)
+      @@url_host_regexes[hosts.sort]
+    end
+
+    @@url_path_regexes = Hash.new do |hash, path|
+      %r|#{PROTOCOL}[^/]+#{Regexp.escape(path)}#{THE_REST}|i
+    end
+
+    def url_regex_for_path(path)
+      @@url_path_regexes[path]
+    end
+
+    @@url_host_and_path_regexes = Hash.new do |hash, (host, path)|
+      %r|#{PROTOCOL}#{CREDENTIALS}#{Regexp.escape(host)}#{PORT}#{Regexp.escape(path)}#{THE_REST}|i
+    end
+
+    def url_regex_for_host_and_path(host, path)
+      @@url_host_and_path_regexes[[host, path]]
+    end
+  end
+end

data/lib/vcr/version.rb

@@ -3,12 +3,23 @@ module VCR
 
   def version
     @version ||= begin
-      string = '1.5.1'
+      string = '1.6.0'
 
-      def string.parts; VCR.version.split('.').map { |p| p.to_i }; end
-      def string.major; parts[0]; end
-      def string.minor; parts[1]; end
-      def string.patch; parts[2]; end
+      def string.parts
+        split('.').map { |p| p.to_i }
+      end
+
+      def string.major
+        parts[0]
+      end
+
+      def string.minor
+        parts[1]
+      end
+
+      def string.patch
+        parts[2]
+      end
 
       string
     end

data/spec/spec_helper.rb

@@ -14,6 +14,25 @@ require 'monkey_patches'
 
 module VCR
   SPEC_ROOT = File.dirname(__FILE__)
+
+  module Config
+    def reset!(stubbing_lib = :fakeweb)
+      self.default_cassette_options = { :record => :new_episodes }
+
+      if stubbing_lib
+        stub_with stubbing_lib
+      else
+        http_stubbing_libraries.clear
+      end
+
+      clear_hooks
+      @ignored_hosts = []
+
+      VCR.instance_eval do
+        instance_variables.each { |ivar| remove_instance_variable(ivar) }
+      end
+    end
+  end
 end
 
 RSpec.configure do |config|
@@ -29,9 +48,7 @@ RSpec.configure do |config|
     VCR.turn_on! unless VCR.turned_on?
     VCR.eject_cassette while VCR.current_cassette
 
-    VCR::Config.default_cassette_options = { :record => :new_episodes }
-    VCR::Config.stub_with :fakeweb
-    VCR::Config.clear_hooks
+    VCR::Config.reset!
 
     WebMock.allow_net_connect!
     WebMock.reset!
@@ -42,6 +59,12 @@ RSpec.configure do |config|
     VCR::HttpStubbingAdapters::Faraday.reset!
   end
 
+  config.after(:each) do
+    VCR::HttpStubbingAdapters::Common.adapters.each do |a|
+      a.ignored_hosts = []
+    end
+  end
+
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true