mustwin-vcr 2.9.3

data/lib/vcr/tasks/vcr.rake

@@ -0,0 +1,9 @@
+namespace :vcr do
+  desc "Migrate cassettes from the VCR 1.x format to the VCR 2.x format."
+  task :migrate_cassettes do
+    dir = ENV.fetch('DIR') { raise "You must pass the cassette library directory as DIR=<directory>" }
+    require 'vcr/cassette/migrator'
+    VCR::Cassette::Migrator.new(dir).migrate!
+  end
+end
+

data/lib/vcr/test_frameworks/cucumber.rb

@@ -0,0 +1,64 @@
+module VCR
+  # Provides integration with Cucumber using tags.
+  class CucumberTags
+    class << self
+      # @private
+      def tags
+        @tags.dup
+      end
+
+      # @private
+      def add_tag(tag)
+        @tags << tag
+      end
+    end
+
+    @tags = []
+
+    # @private
+    def initialize(main_object)
+      @main_object = main_object
+    end
+
+    # Adds `Before` and `After` cucumber hooks for the named tags that
+    # will cause a VCR cassette to be used for scenarios with matching tags.
+    #
+    # @param [Array<String>] tag_names the cucumber scenario tags
+    # @param [(optional) Hash] options the cassette options. Specify
+    #   `:use_scenario_name => true` to automatically name the
+    #   cassette according to the scenario name.
+    def tags(*tag_names)
+      original_options = tag_names.last.is_a?(::Hash) ? tag_names.pop : {}
+      tag_names.each do |tag_name|
+        tag_name = "@#{tag_name}" unless tag_name =~ /\A@/
+
+        # It would be nice to use an Around hook here, but
+        # cucumber has a bug: background steps do not run
+        # within an around hook.
+        # https://gist.github.com/652968
+        @main_object.Before(tag_name) do |scenario|
+          options = original_options.dup
+
+          cassette_name = if options.delete(:use_scenario_name)
+            feature = scenario.respond_to?(:scenario_outline) ? scenario.scenario_outline.feature : scenario.feature
+            name = feature.name.split("\n").first
+            name << "/#{scenario.scenario_outline.name}" if scenario.respond_to?(:scenario_outline)
+            name << "/#{scenario.name.split("\n").first}"
+            name
+          else
+            "cucumber_tags/#{tag_name.gsub(/\A@/, '')}"
+          end
+
+          VCR.insert_cassette(cassette_name, options)
+        end
+
+        @main_object.After(tag_name) do |scenario|
+          VCR.eject_cassette(:skip_no_unused_interactions_assertion => scenario.failed?)
+        end
+
+        self.class.add_tag(tag_name)
+      end
+    end
+    alias :tag :tags
+  end
+end

data/lib/vcr/test_frameworks/rspec.rb

@@ -0,0 +1,47 @@
+module VCR
+  # Integrates VCR with RSpec.
+  module RSpec
+    # @private
+    module Metadata
+      extend self
+
+      def configure!
+        ::RSpec.configure do |config|
+          vcr_cassette_name_for = lambda do |metadata|
+            description = metadata[:description]
+            example_group = if metadata.key?(:example_group)
+                              metadata[:example_group]
+                            else
+                              metadata[:parent_example_group]
+                            end
+
+            if example_group
+              [vcr_cassette_name_for[example_group], description].join('/')
+            else
+              description
+            end
+          end
+
+          when_tagged_with_vcr = { :vcr => lambda { |v| !!v } }
+
+          config.before(:each, when_tagged_with_vcr) do |ex|
+            example = ex.respond_to?(:metadata) ? ex : ex.example
+
+            options = example.metadata[:vcr]
+            options = options.is_a?(Hash) ? options.dup : {} # in case it's just :vcr => true
+
+            cassette_name = options.delete(:cassette_name) ||
+                            vcr_cassette_name_for[example.metadata]
+            VCR.insert_cassette(cassette_name, options)
+          end
+
+          config.after(:each, when_tagged_with_vcr) do |ex|
+            example = ex.respond_to?(:metadata) ? ex : ex.example
+            VCR.eject_cassette(:skip_no_unused_interactions_assertion => !!example.exception)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vcr/util/hooks.rb

@@ -0,0 +1,61 @@
+require 'vcr/util/variable_args_block_caller'
+
+module VCR
+  # @private
+  module Hooks
+    include VariableArgsBlockCaller
+
+    FilteredHook = Struct.new(:hook, :filters) do
+      include VariableArgsBlockCaller
+
+      def conditionally_invoke(*args)
+        filters = Array(self.filters)
+        return if filters.any? { |f| !call_block(f.to_proc, *args) }
+        call_block(hook, *args)
+      end
+    end
+
+    def self.included(klass)
+      klass.class_eval do
+        extend ClassMethods
+        hooks_module = Module.new
+        const_set("DefinedHooks", hooks_module)
+        include hooks_module
+      end
+    end
+
+    def invoke_hook(hook_type, *args)
+      hooks[hook_type].map do |hook|
+        hook.conditionally_invoke(*args)
+      end
+    end
+
+    def clear_hooks
+      hooks.clear
+    end
+
+    def hooks
+      @hooks ||= Hash.new do |hash, hook_type|
+        hash[hook_type] = []
+      end
+    end
+
+    def has_hooks_for?(hook_type)
+      hooks[hook_type].any?
+    end
+
+    # @private
+    module ClassMethods
+      def define_hook(hook_type, prepend = false)
+        placement_method = prepend ? :unshift : :<<
+
+        # Put the hook methods in a module so we can override and super to these methods.
+        self::DefinedHooks.module_eval do
+          define_method hook_type do |*filters, &hook|
+            hooks[hook_type].send(placement_method, FilteredHook.new(hook, filters))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vcr/util/internet_connection.rb

@@ -0,0 +1,43 @@
+module VCR
+  # Ruby 1.8 provides Ping.pingecho, but it was removed in 1.9.
+  # So we try requiring it, and if that fails, define it ourselves.
+  begin
+    require 'ping'
+    Ping = ::Ping
+  rescue LoadError
+    # This is copied, verbatim, from Ruby 1.8.7's ping.rb.
+    require 'timeout'
+    require "socket"
+
+    # @private
+    module Ping
+      def pingecho(host, timeout=5, service="echo")
+        begin
+          timeout(timeout) do
+            s = TCPSocket.new(host, service)
+            s.close
+          end
+        rescue Errno::ECONNREFUSED
+          return true
+        rescue Timeout::Error, StandardError
+          return false
+        end
+        return true
+      end
+      module_function :pingecho
+    end
+  end
+
+  # @private
+  module InternetConnection
+    extend self
+
+    EXAMPLE_HOST = "example.com"
+
+    def available?
+      @available = VCR::Ping.pingecho(EXAMPLE_HOST, 1, 80) unless defined?(@available)
+      @available
+    end
+  end
+end
+

data/lib/vcr/util/logger.rb

@@ -0,0 +1,59 @@
+module VCR
+  # @private
+  # Provides log message formatting helper methods.
+  class Logger
+    def initialize(stream)
+      @stream = stream
+    end
+
+    def log(message, log_prefix, indentation_level = 0)
+      indentation = '  ' * indentation_level
+      log_message = indentation + log_prefix + message
+      @stream.puts log_message
+    end
+
+    def request_summary(request, request_matchers)
+      attributes = [request.method, request.uri]
+      attributes << request.body.to_s[0, 80].inspect if request_matchers.include?(:body)
+      attributes << request.headers.inspect          if request_matchers.include?(:headers)
+      "[#{attributes.join(" ")}]"
+    end
+
+    def response_summary(response)
+      "[#{response.status.code} #{response.body[0, 80].inspect}]"
+    end
+
+    # @private
+    # A null-object version of the Logger. Used when
+    # a `debug_logger` has not been set.
+    #
+    # @note We used to use a null object for the `debug_logger` itself,
+    #       but some users noticed a negative perf impact from having the
+    #       logger formatting logic still executing in that case, so we
+    #       moved the null object interface up a layer to here.
+    module Null
+      module_function
+
+      def log(*); end
+      def request_summary(*); end
+      def response_summary(*); end
+    end
+
+    # @private
+    # Provides common logger helper methods that simply delegate to
+    # the underlying logger object.
+    module Mixin
+      def log(message, indentation_level = 0)
+        VCR.configuration.logger.log(message, log_prefix, indentation_level)
+      end
+
+      def request_summary(*args)
+        VCR.configuration.logger.request_summary(*args)
+      end
+
+      def response_summary(*args)
+        VCR.configuration.logger.response_summary(*args)
+      end
+    end
+  end
+end

data/lib/vcr/util/variable_args_block_caller.rb

@@ -0,0 +1,13 @@
+module VCR
+  # @private
+  module VariableArgsBlockCaller
+    def call_block(block, *args)
+      if block.arity >= 0
+        args = args.first([args.size, block.arity].min)
+      end
+
+      block.call(*args)
+    end
+  end
+end
+

data/lib/vcr/util/version_checker.rb

@@ -0,0 +1,48 @@
+module VCR
+  # @private
+  class VersionChecker
+    def initialize(library_name, library_version, min_version)
+      @library_name    = library_name
+      @library_version = library_version
+      @min_version     = min_version
+
+      @major,     @minor,     @patch     = parse_version(library_version)
+      @min_major, @min_minor, @min_patch = parse_version(min_version)
+    end
+
+    def check_version!
+      raise_too_low_error if too_low?
+    end
+
+  private
+
+    def too_low?
+      compare_version == :too_low
+    end
+
+    def raise_too_low_error
+      raise Errors::LibraryVersionTooLowError,
+        "You are using #{@library_name} #{@library_version}. " +
+        "VCR requires version #{version_requirement}."
+    end
+
+    def compare_version
+      case
+        when @major < @min_major then :too_low
+        when @major > @min_major then :ok
+        when @minor < @min_minor then :too_low
+        when @minor > @min_minor then :ok
+        when @patch < @min_patch then :too_low
+      end
+    end
+
+    def version_requirement
+      ">= #{@min_version}"
+    end
+
+    def parse_version(version)
+      version.split('.').map { |v| v.to_i }
+    end
+  end
+end
+

data/lib/vcr/version.rb

@@ -0,0 +1,34 @@
+module VCR
+  extend self
+
+  # @return [String] the current VCR version.
+  # @note This string also has singleton methods:
+  #
+  #   * `major` [Integer] The major version.
+  #   * `minor` [Integer] The minor version.
+  #   * `patch` [Integer] The patch version.
+  #   * `parts` [Array<Integer>] List of the version parts.
+  def version
+    @version ||= begin
+      string = '2.9.3'
+
+      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
+  end
+end

data/spec/acceptance/threading_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe VCR do
+  context 'when used in a multithreaded environment', :with_monkey_patches => :excon do
+    def preload_yaml_serializer_to_avoid_circular_require_warning_race_condition
+      VCR.cassette_serializers[:yaml]
+    end
+
+    before { preload_yaml_serializer_to_avoid_circular_require_warning_race_condition }
+
+    def recorded_content_for(name)
+      VCR.cassette_persisters[:file_system]["#{name}.yml"].to_s
+    end
+
+    it 'can use a cassette in an #around_http_request hook', :if => (RUBY_VERSION.to_f > 1.8) do
+      VCR.configure do |vcr|
+        vcr.around_http_request do |req|
+          VCR.use_cassette(req.parsed_uri.path, &req)
+        end
+      end
+
+      thread = Thread.start do
+        Excon.get "http://localhost:#{VCR::SinatraApp.port}/search?q=thread"
+      end
+
+      Excon.get "http://localhost:#{VCR::SinatraApp.port}/foo",
+        :response_block => Proc.new { thread.join }
+
+      expect(recorded_content_for("search") +
+             recorded_content_for("foo")).to include("query: thread", "FOO!")
+    end
+  end
+end
+

data/spec/fixtures/cassette_spec/1_x_cassette.yml

@@ -0,0 +1,110 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :get
+    uri: http://example.com:80/
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      last-modified: 
+      - Tue, 15 Nov 2005 13:24:10 GMT
+      connection: 
+      - Keep-Alive
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      content-type: 
+      - text/html; charset=UTF-8
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "3009"
+      accept-ranges: 
+      - bytes
+    body: |
+      <HTML>
+      <HEAD>
+        <TITLE>Example Web Page</TITLE>
+      </HEAD> 
+      <body>  
+      <p>You have reached this web page by typing &quot;example.com&quot;,
+      &quot;example.net&quot;,
+        or &quot;example.org&quot; into your web browser.</p>
+      <p>These domain names are reserved for use in documentation and are not available 
+        for registration. See <a href="http://www.rfc-editor.org/rfc/rfc2606.txt">RFC 
+        2606</a>, Section 3.</p>
+      </BODY>
+      </HTML>
+
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :get
+    uri: http://example.com:80/foo
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 404
+      message: Not Found
+    headers: 
+      connection: 
+      - close
+      content-type: 
+      - text/html; charset=iso-8859-1
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "277"
+    body: |
+      <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+      <html><head>
+      <title>404 Not Found</title>
+      </head><body>
+      <h1>Not Found</h1>
+      <p>The requested URL /foo was not found on this server.</p>
+      <hr>
+      <address>Apache/2.2.3 (CentOS) Server at example.com Port 80</address>
+      </body></html>
+
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :get
+    uri: http://example.com:80/
+    body: 
+    headers: 
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      last-modified: 
+      - Tue, 15 Nov 2005 13:24:10 GMT
+      connection: 
+      - Keep-Alive
+      date: 
+      - Thu, 25 Feb 2010 07:52:38 GMT
+      content-type: 
+      - text/html; charset=UTF-8
+      etag: 
+      - "\"24ec5-1b6-4059a80bfd280\""
+      server: 
+      - Apache/2.2.3 (CentOS)
+      content-length: 
+      - "438"
+      age: 
+      - "3009"
+      accept-ranges: 
+      - bytes
+    body: Another example.com response
+    http_version: "1.1"