vcr 2.0.0.beta1 → 2.0.0.beta2

data/lib/vcr/cassette/migrator.rb

@@ -0,0 +1,111 @@
+require 'yaml'
+require 'vcr/structs'
+require 'uri'
+
+module VCR
+  class Cassette
+    class Migrator
+      def initialize(dir, out = $stdout)
+        @dir, @out = dir, out
+        @yaml_load_errors = yaml_load_errors
+      end
+
+      def migrate!
+        @out.puts "Migrating VCR cassettes in #{@dir}..."
+        Dir["#{@dir}/**/*.yml"].each do |cassette|
+          migrate_cassette(cassette)
+        end
+      end
+
+    private
+
+      def migrate_cassette(cassette)
+        unless http_interactions = load_yaml(cassette)
+          @out.puts "  - Ignored #{relative_casssette_name(cassette)} since it could not be parsed as YAML (does it have some ERB?)"
+          return
+        end
+
+        unless valid_vcr_1_cassette?(http_interactions)
+          @out.puts "  - Ignored #{relative_casssette_name(cassette)} since it does not appear to be a valid VCR 1.x cassette"
+          return
+        end
+
+        http_interactions.map! do |interaction|
+          interaction.recorded_at = File.mtime(cassette)
+          remove_unnecessary_standard_port(interaction)
+          denormalize_http_header_keys(interaction.request)
+          denormalize_http_header_keys(interaction.response)
+          normalize_body(interaction.request)
+          normalize_body(interaction.response)
+          interaction.to_hash
+        end
+
+        hash = {
+          "http_interactions" => http_interactions,
+          "recorded_with"     => "VCR 1.11.3" # assume the last 1.x release
+        }
+
+        def hash.each
+          yield 'http_interactions', self['http_interactions']
+          yield 'recorded_with', self['recorded_with']
+        end
+
+        File.open(cassette, 'w') { |f| f.write ::YAML.dump(hash) }
+        @out.puts "  - Migrated #{relative_casssette_name(cassette)}"
+      end
+
+      def load_yaml(cassette)
+        ::YAML.load_file(cassette)
+      rescue *@yaml_load_errors
+        return nil
+      end
+
+      def yaml_load_errors
+        [ArgumentError].tap do |errors|
+          errors << Psych::SyntaxError if defined?(Psych::SyntaxError)
+        end
+      end
+
+      def relative_casssette_name(cassette)
+        cassette.gsub(%r|\A#{Regexp.escape(@dir)}/?|, '')
+      end
+
+      def valid_vcr_1_cassette?(content)
+        content.is_a?(Array) &&
+        content.map(&:class).uniq == [HTTPInteraction]
+      end
+
+      def remove_unnecessary_standard_port(interaction)
+        uri = URI(interaction.request.uri)
+        if uri.scheme == 'http'  && uri.port == 80 ||
+           uri.scheme == 'https' && uri.port == 443
+          uri.port = nil
+          interaction.request.uri = uri.to_s
+        end
+      rescue URI::InvalidURIError
+        # ignore this URI.
+        # This can occur when the user uses the filter_sensitive_data option
+        # to put a substitution string in their URI
+      end
+
+      def denormalize_http_header_keys(object)
+        object.headers = {}.tap do |denormalized|
+          object.headers.each do |k, v|
+            denormalized[denormalize_header_key(k)] = v
+          end if object.headers
+        end
+      end
+
+      def denormalize_header_key(key)
+        key.split('-').               # 'user-agent' => %w(user agent)
+          each { |w| w.capitalize! }. # => %w(User Agent)
+          join('-')
+      end
+
+      def normalize_body(object)
+        object.body = '' if object.body.nil?
+      end
+    end
+  end
+end
+

data/lib/vcr/cassette/serializers.rb

@@ -0,0 +1,35 @@
+module VCR
+  class Cassette
+    class Serializers
+      autoload :YAML,  'vcr/cassette/serializers/yaml'
+      autoload :Syck,  'vcr/cassette/serializers/syck'
+      autoload :Psych, 'vcr/cassette/serializers/psych'
+      autoload :JSON,  'vcr/cassette/serializers/json'
+
+      def initialize
+        @serializers = {}
+      end
+
+      def [](name)
+        @serializers.fetch(name) do |_|
+          @serializers[name] = case name
+            when :yaml  then YAML
+            when :syck  then Syck
+            when :psych then Psych
+            when :json  then JSON
+            else raise ArgumentError.new("The requested VCR cassette serializer (#{name.inspect}) is not registered.")
+          end
+        end
+      end
+
+      def []=(name, value)
+        if @serializers.has_key?(name)
+          warn "WARNING: There is already a VCR cassette serializer registered for #{name.inspect}. Overriding it."
+        end
+
+        @serializers[name] = value
+      end
+    end
+  end
+end
+

data/lib/vcr/cassette/serializers/json.rb

@@ -0,0 +1,23 @@
+require 'multi_json'
+
+module VCR
+  class Cassette
+    class Serializers
+      module JSON
+        extend self
+
+        def file_extension
+          "json"
+        end
+
+        def serialize(hash)
+          MultiJson.encode(hash)
+        end
+
+        def deserialize(string)
+          MultiJson.decode(string)
+        end
+      end
+    end
+  end
+end

data/lib/vcr/cassette/serializers/psych.rb

@@ -0,0 +1,24 @@
+require 'psych'
+
+module VCR
+  class Cassette
+    class Serializers
+      module Psych
+        extend self
+
+        def file_extension
+          "yml"
+        end
+
+        def serialize(hash)
+          ::Psych.dump(hash)
+        end
+
+        def deserialize(string)
+          ::Psych.load(string)
+        end
+      end
+    end
+  end
+end
+

data/lib/vcr/cassette/serializers/syck.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+
+module VCR
+  class Cassette
+    class Serializers
+      module Syck
+        extend self
+
+        def file_extension
+          "yml"
+        end
+
+        def serialize(hash)
+          using_syck { ::YAML.dump(hash) }
+        end
+
+        def deserialize(string)
+          using_syck { ::YAML.load(string) }
+        end
+
+        def using_syck
+          return yield unless defined?(::YAML::ENGINE)
+          original_engine = ::YAML::ENGINE.yamler
+          ::YAML::ENGINE.yamler = 'syck'
+
+          begin
+            yield
+          ensure
+            ::YAML::ENGINE.yamler = original_engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vcr/cassette/serializers/yaml.rb

@@ -0,0 +1,24 @@
+require 'yaml'
+
+module VCR
+  class Cassette
+    class Serializers
+      module YAML
+        extend self
+
+        def file_extension
+          "yml"
+        end
+
+        def serialize(hash)
+          ::YAML.dump(hash)
+        end
+
+        def deserialize(string)
+          ::YAML.load(string)
+        end
+      end
+    end
+  end
+end
+

data/lib/vcr/configuration.rb

@@ -14,7 +14,8 @@ module VCR
       @allow_http_connections_when_no_cassette = nil
       @default_cassette_options = {
         :record            => :once,
-        :match_requests_on => RequestMatcherRegistry::DEFAULT_MATCHERS
+        :match_requests_on => RequestMatcherRegistry::DEFAULT_MATCHERS,
+        :serialize_with    => :yaml
       }
     end
 
@@ -62,6 +63,10 @@ module VCR
       end
     end
 
+    def cassette_serializers
+      VCR.cassette_serializers
+    end
+
   private
 
     def load_library_hook(hook)

data/lib/vcr/errors.rb

@@ -6,7 +6,7 @@ module VCR
     class MissingERBVariableError   < Error; end
     class LibraryVersionTooLowError < Error; end
     class UnregisteredMatcherError  < Error; end
-
+    class InvalidCassetteFormatError < Error; end
 
     class HTTPConnectionNotAllowedError < Error
       def initialize(request)

data/lib/vcr/library_hooks/excon.rb

@@ -112,17 +112,11 @@ module VCR
           normalized = {}
           headers.each do |k, v|
             v = v.join(', ') if v.respond_to?(:join)
-            normalized[normalize_header_key(k)] = v
+            normalized[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
-
         ::Excon.stub({}) do |params|
           self.new(params).handle
         end

data/lib/vcr/library_hooks/typhoeus.rb

@@ -2,7 +2,7 @@ require 'vcr/util/version_checker'
 require 'vcr/request_handler'
 require 'typhoeus'
 
-VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.2.1', '0.2').check_version!
+VCR::VersionChecker.new('Typhoeus', Typhoeus::VERSION, '0.3.2', '0.3').check_version!
 
 module VCR
   class LibraryHooks
@@ -35,16 +35,12 @@ module VCR
 
       private
 
-        def on_stubbed_request
-          hydra_mock
-        end
-
         def vcr_request
           @vcr_request ||= vcr_request_from(request)
         end
 
-        def typhoeus_response
-          @typhoeus_response ||= ::Typhoeus::Response.new \
+        def on_stubbed_request
+          ::Typhoeus::Response.new \
             :http_version   => stubbed_response.http_version,
             :code           => stubbed_response.status.code,
             :status_message => stubbed_response.status.message,
@@ -52,12 +48,6 @@ module VCR
             :body           => stubbed_response.body
         end
 
-        def hydra_mock
-          @hydra_mock ||= ::Typhoeus::HydraMock.new(/.*/, :any).tap do |m|
-            m.and_return(typhoeus_response)
-          end
-        end
-
         def stubbed_response_headers
           @stubbed_response_headers ||= {}.tap do |hash|
             stubbed_response.headers.each do |key, values|
@@ -75,19 +65,13 @@ module VCR
         end
       end
 
+      ::Typhoeus::Hydra.register_stub_finder do |request|
+        VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
+      end
     end
   end
 end
 
-# TODO: add Typhoeus::Hydra.register_stub_finder API to Typhoeus
-#       so we can use that instead of monkey-patching it.
-Typhoeus::Hydra::Stubbing::SharedMethods.class_eval do
-  undef find_stub_from_request
-  def find_stub_from_request(request)
-    VCR::LibraryHooks::Typhoeus::RequestHandler.new(request).handle
-  end
-end
-
 VCR.configuration.after_library_hooks_loaded do
   # ensure WebMock's Typhoeus adapter does not conflict with us here
   # (i.e. to double record requests or whatever).

data/lib/vcr/library_hooks/webmock.rb

@@ -29,7 +29,7 @@ module VCR
             VCR::ResponseStatus.new(response.status.first, response.status.last),
             response.headers,
             response.body,
-            '1.1'
+            nil
         end
       end
 

data/lib/vcr/middleware/faraday.rb

@@ -45,7 +45,7 @@ module VCR
             VCR::ResponseStatus.new(response.status, nil),
             response.headers,
             response.body,
-            '1.1'
+            nil
           )
         end
 

data/lib/vcr/request_matcher_registry.rb

@@ -1,3 +1,5 @@
+require 'vcr/errors'
+
 module VCR
   class RequestMatcherRegistry
     DEFAULT_MATCHERS = [:method, :uri]
@@ -8,6 +10,33 @@ module VCR
       end
     end
 
+    class URIWithoutParamsMatcher < Struct.new(:params_to_ignore)
+      def partial_uri_from(request)
+        URI(request.uri).tap do |uri|
+          break unless uri.query # ignore uris without params, e.g. "http://example.com/"
+
+          uri.query = uri.query.split('&').tap { |params|
+            params.map! do |p|
+              key, value = p.split('=')
+              key.gsub!(/\[\]\z/, '') # handle params like tag[]=
+              [key, value]
+            end
+
+            params.reject! { |p| params_to_ignore.include?(p.first) }
+            params.map!    { |p| p.join('=') }
+          }.join('&')
+        end
+      end
+
+      def call(request_1, request_2)
+        partial_uri_from(request_1) == partial_uri_from(request_2)
+      end
+
+      def to_proc
+        lambda { |r1, r2| call(r1, r2) }
+      end
+    end
+
     def initialize
       @registry = {}
       register_built_ins
@@ -30,31 +59,19 @@ module VCR
     end
 
     def uri_without_params(*ignores)
-      ignores = ignores.map { |i| i.to_s }
-
-      lambda do |request_1, request_2|
-        uri_1, uri_2 = [request_1, request_2].map do |r|
-          URI(r.uri).tap do |uri|
-            uri.query = uri.query.split('&').tap { |params|
-              params.map! do |p|
-                key, value = p.split('=')
-                key.gsub!(/\[\]\z/, '') # handle params like tag[]=
-                [key, value]
-              end
-
-              params.reject! { |p| ignores.include?(p.first) }
-              params.map!    { |p| p.join('=') }
-            }.join('&')
-          end
-        end
-
-        uri_1 == uri_2
-      end
+      uri_without_param_matchers[ignores]
     end
     alias uri_without_param uri_without_params
 
   private
 
+    def uri_without_param_matchers
+      @uri_without_param_matchers ||= Hash.new do |hash, params|
+        params = params.map(&:to_s)
+        hash[params] = URIWithoutParamsMatcher.new(params)
+      end
+    end
+
     def raise_unregistered_matcher_error(name)
       raise Errors::UnregisteredMatcherError.new \
         "There is no matcher registered for #{name.inspect}. " +
@@ -63,22 +80,18 @@ module VCR
 
     def register_built_ins
       register(:method)  { |r1, r2| r1.method == r2.method }
-      register(:uri)     { |r1, r2| normalize_uri(r1.uri) == normalize_uri(r2.uri) }
+      register(:uri)     { |r1, r2| without_standard_port(r1.uri) == without_standard_port(r2.uri) }
       register(:host)    { |r1, r2| URI(r1.uri).host == URI(r2.uri).host }
       register(:path)    { |r1, r2| URI(r1.uri).path == URI(r2.uri).path }
       register(:body)    { |r1, r2| r1.body == r2.body }
       register(:headers) { |r1, r2| r1.headers == r2.headers }
     end
 
-    def normalize_uri(uri)
-      # TODO: find a better, less-hacky way to do this.
-      if defined?(::WebMock)
-        ::WebMock::Util::URI.normalize_uri(uri).to_s
-      elsif defined?(VCR::Middleware::Faraday)
-        # Faraday normalizes URIs by replacing '+' with '%20'
-        uri.gsub('+', '%20')
-      else
-        uri
+    def without_standard_port(uri)
+      URI(uri).tap do |u|
+        if [['http', 80], ['https', 443]].include?([u.scheme, u.port])
+          u.port = nil
+        end
       end
     end
   end