mustwin-vcr 2.9.3

data/lib/vcr/cassette/erb_renderer.rb

@@ -0,0 +1,55 @@
+require 'erb'
+
+module VCR
+  class Cassette
+    # @private
+    class ERBRenderer
+      def initialize(raw_template, erb, cassette_name=nil)
+        @raw_template, @erb, @cassette_name = raw_template, erb, cassette_name
+      end
+
+      def render
+        return @raw_template if @raw_template.nil? || !use_erb?
+        binding = binding_for_variables if erb_variables
+        template.result(binding)
+      rescue NameError => e
+        handle_name_error(e)
+      end
+
+    private
+
+      def handle_name_error(e)
+        example_hash = (erb_variables || {}).merge(e.name => 'some value')
+
+        raise Errors::MissingERBVariableError.new(
+          "The ERB in the #{@cassette_name} cassette file references undefined variable #{e.name}.  " +
+          "Pass it to the cassette using :erb => #{ example_hash.inspect }."
+        )
+      end
+
+      def use_erb?
+        !!@erb
+      end
+
+      def erb_variables
+        @erb if @erb.is_a?(Hash)
+      end
+
+      def template
+        @template ||= ERB.new(@raw_template)
+      end
+
+      @@struct_cache = Hash.new do |hash, attributes|
+        hash[attributes] = Struct.new(*attributes)
+      end
+
+      def variables_object
+        @variables_object ||= @@struct_cache[erb_variables.keys].new(*erb_variables.values)
+      end
+
+      def binding_for_variables
+        @binding_for_variables ||= variables_object.instance_eval { binding }
+      end
+    end
+  end
+end

data/lib/vcr/cassette/http_interaction_list.rb

@@ -0,0 +1,108 @@
+module VCR
+  class Cassette
+    # @private
+    class HTTPInteractionList
+      include Logger::Mixin
+
+      # @private
+      module NullList
+        extend self
+        def response_for(*a); nil; end
+        def has_interaction_matching?(*a); false; end
+        def has_used_interaction_matching?(*a); false; end
+        def remaining_unused_interaction_count(*a); 0; end
+      end
+
+      attr_reader :interactions, :request_matchers, :allow_playback_repeats, :parent_list
+
+      def initialize(interactions, request_matchers, allow_playback_repeats = false, parent_list = NullList, log_prefix = '')
+        @interactions           = interactions.dup
+        @request_matchers       = request_matchers
+        @allow_playback_repeats = allow_playback_repeats
+        @parent_list            = parent_list
+        @used_interactions      = []
+        @log_prefix             = log_prefix
+
+        interaction_summaries = interactions.map { |i| "#{request_summary(i.request)} => #{response_summary(i.response)}" }
+        log "Initialized HTTPInteractionList with request matchers #{request_matchers.inspect} and #{interactions.size} interaction(s): { #{interaction_summaries.join(', ')} }", 1
+      end
+
+      def response_for(request)
+        if index = matching_interaction_index_for(request)
+          interaction = @interactions.delete_at(index)
+          @used_interactions.unshift interaction
+          log "Found matching interaction for #{request_summary(request)} at index #{index}: #{response_summary(interaction.response)}", 1
+          interaction.response
+        elsif interaction = matching_used_interaction_for(request)
+          interaction.response
+        else
+          @parent_list.response_for(request)
+        end
+      end
+
+      def has_interaction_matching?(request)
+        !!matching_interaction_index_for(request) ||
+        !!matching_used_interaction_for(request) ||
+        @parent_list.has_interaction_matching?(request)
+      end
+
+      def has_used_interaction_matching?(request)
+        @used_interactions.any? { |i| interaction_matches_request?(request, i) }
+      end
+
+      def remaining_unused_interaction_count
+        @interactions.size
+      end
+
+      # Checks if there are no unused interactions left.
+      #
+      # @raise [VCR::Errors::UnusedHTTPInteractionError] if not all interactions were played back.
+      def assert_no_unused_interactions!
+        return unless has_unused_interactions?
+        logger = Logger.new(nil)
+
+        descriptions = @interactions.map do |i|
+          "  - #{logger.request_summary(i.request, @request_matchers)} => #{logger.response_summary(i.response)}"
+        end.join("\n")
+
+        raise Errors::UnusedHTTPInteractionError, "There are unused HTTP interactions left in the cassette:\n#{descriptions}"
+      end
+
+    private
+
+      # @return [Boolean] Whether or not there are unused interactions left in the list.
+      def has_unused_interactions?
+        @interactions.size > 0
+      end
+
+      def request_summary(request)
+        super(request, @request_matchers)
+      end
+
+      def matching_interaction_index_for(request)
+        @interactions.index { |i| interaction_matches_request?(request, i) }
+      end
+
+      def matching_used_interaction_for(request)
+        return nil unless @allow_playback_repeats
+        @used_interactions.find { |i| interaction_matches_request?(request, i) }
+      end
+
+      def interaction_matches_request?(request, interaction)
+        log "Checking if #{request_summary(request)} matches #{request_summary(interaction.request)} using #{@request_matchers.inspect}", 1
+        @request_matchers.all? do |matcher_name|
+          matcher = VCR.request_matchers[matcher_name]
+          matcher.matches?(request, interaction.request).tap do |matched|
+            matched = matched ? 'matched' : 'did not match'
+            log "#{matcher_name} (#{matched}): current request #{request_summary(request)} vs #{request_summary(interaction.request)}", 2
+          end
+        end
+      end
+
+      def log_prefix
+        @log_prefix
+      end
+    end
+  end
+end
+

data/lib/vcr/cassette/migrator.rb

@@ -0,0 +1,118 @@
+require 'vcr'
+
+module VCR
+  class Cassette
+    # @private
+    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.response.adapter_metadata = {}
+          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 #{VCR.version}"
+        }
+
+        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 = VCR.configuration.uri_parser.parse(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
+
+      EMPTY_STRING = if String.method_defined?(:force_encoding)
+        ''.force_encoding("US-ASCII")
+      else
+        ''
+      end
+
+      def normalize_body(object)
+        object.body = EMPTY_STRING if object.body.nil?
+      end
+
+    end
+  end
+end
+

data/lib/vcr/cassette/persisters.rb

@@ -0,0 +1,42 @@
+module VCR
+  class Cassette
+    # Keeps track of the cassette persisters in a hash-like object.
+    class Persisters
+      autoload :FileSystem, 'vcr/cassette/persisters/file_system'
+
+      # @private
+      def initialize
+        @persisters = {}
+      end
+
+      # Gets the named persister.
+      #
+      # @param name [Symbol] the name of the persister
+      # @return the named persister
+      # @raise [ArgumentError] if there is not a persister for the given name
+      def [](name)
+        @persisters.fetch(name) do |_|
+          @persisters[name] = case name
+            when :file_system then FileSystem
+            else raise ArgumentError, "The requested VCR cassette persister " +
+                                      "(#{name.inspect}) is not registered."
+          end
+        end
+      end
+
+      # Registers a persister.
+      #
+      # @param name [Symbol] the name of the persister
+      # @param value [#[], #[]=] the persister object. It must implement `[]` and `[]=`.
+      def []=(name, value)
+        if @persisters.has_key?(name)
+          warn "WARNING: There is already a VCR cassette persister " +
+               "registered for #{name.inspect}. Overriding it."
+        end
+
+        @persisters[name] = value
+      end
+
+    end
+  end
+end

data/lib/vcr/cassette/persisters/file_system.rb

@@ -0,0 +1,64 @@
+require 'fileutils'
+
+module VCR
+  class Cassette
+    class Persisters
+      # The only built-in cassette persister. Persists cassettes to the file system.
+      module FileSystem
+        extend self
+
+        # @private
+        attr_reader :storage_location
+
+        # @private
+        def storage_location=(dir)
+          FileUtils.mkdir_p(dir) if dir
+          @storage_location = dir ? absolute_path_for(dir) : nil
+        end
+
+        # Gets the cassette for the given storage key (file name).
+        #
+        # @param [String] file_name the file name
+        # @return [String] the cassette content
+        def [](file_name)
+          path = absolute_path_to_file(file_name)
+          return nil unless File.exist?(path)
+          File.read(path)
+        end
+
+        # Sets the cassette for the given storage key (file name).
+        #
+        # @param [String] file_name the file name
+        # @param [String] content the content to store
+        def []=(file_name, content)
+          path = absolute_path_to_file(file_name)
+          directory = File.dirname(path)
+          FileUtils.mkdir_p(directory) unless File.exist?(directory)
+          File.open(path, 'w') { |f| f.write(content) }
+        end
+
+        # @private
+        def absolute_path_to_file(file_name)
+          return nil unless storage_location
+          File.join(storage_location, sanitized_file_name_from(file_name))
+        end
+
+      private
+
+        def absolute_path_for(path)
+          Dir.chdir(path) { Dir.pwd }
+        end
+
+        def sanitized_file_name_from(file_name)
+          parts = file_name.to_s.split('.')
+
+          if parts.size > 1 && !parts.last.include?(File::SEPARATOR)
+            file_extension = '.' + parts.pop
+          end
+
+          parts.join('.').gsub(/[^\w\-\/]+/, '_') + file_extension.to_s
+        end
+      end
+    end
+  end
+end

data/lib/vcr/cassette/serializers.rb

@@ -0,0 +1,57 @@
+module VCR
+  class Cassette
+    # Keeps track of the cassette serializers in a hash-like object.
+    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'
+
+      # @private
+      def initialize
+        @serializers = {}
+      end
+
+      # Gets the named serializer.
+      #
+      # @param name [Symbol] the name of the serializer
+      # @return the named serializer
+      # @raise [ArgumentError] if there is not a serializer for the given name
+      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
+
+      # Registers a serializer.
+      #
+      # @param name [Symbol] the name of the serializer
+      # @param value [#file_extension, #serialize, #deserialize] the serializer object. It must implement
+      #  `file_extension()`, `serialize(Hash)` and `deserialize(String)`.
+      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
+
+    # @private
+    module EncodingErrorHandling
+      def handle_encoding_errors
+        yield
+      rescue *self::ENCODING_ERRORS => e
+        e.message << "\nNote: Using VCR's `:preserve_exact_body_bytes` option may help prevent this error in the future."
+        raise
+      end
+    end
+  end
+end
+