mustwin-vcr 2.9.3

data/features/request_matching/uri.feature

@@ -0,0 +1,94 @@
+Feature: Matching on URI
+
+  Use the `:uri` request matcher to match requests on the request URI.
+
+  The `:uri` matcher is used (along with the `:method` matcher) by default
+  if you do not specify how requests should match.
+
+  Background:
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: post
+          uri: http://example.com/foo
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "12"
+          body: 
+            encoding: UTF-8
+            string: foo response
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      - request: 
+          method: post
+          uri: http://example.com/bar
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "12"
+          body: 
+            encoding: UTF-8
+            string: bar response
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
+      """
+
+  Scenario Outline: Replay interaction that matches the request URI
+    And a file named "uri_matching.rb" with:
+      """ruby
+      include_http_adapter_for("<http_lib>")
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        <configuration>
+        c.cassette_library_dir = 'cassettes'
+      end
+
+      VCR.use_cassette('example', :match_requests_on => [:uri]) do
+        puts "Response for /bar: " + response_body_for(:get, "http://example.com/bar")
+      end
+
+      VCR.use_cassette('example', :match_requests_on => [:uri]) do
+        puts "Response for /foo: " + response_body_for(:get,  "http://example.com/foo")
+      end
+      """
+    When I run `ruby uri_matching.rb`
+    Then it should pass with:
+      """
+      Response for /bar: bar response
+      Response for /foo: foo response
+      """
+
+    Examples:
+      | configuration         | http_lib              |
+      | c.hook_into :fakeweb  | net/http              |
+      | c.hook_into :webmock  | net/http              |
+      | c.hook_into :webmock  | httpclient            |
+      | c.hook_into :webmock  | curb                  |
+      | c.hook_into :webmock  | patron                |
+      | c.hook_into :webmock  | em-http-request       |
+      | c.hook_into :webmock  | typhoeus              |
+      | c.hook_into :typhoeus | typhoeus              |
+      | c.hook_into :excon    | excon                 |
+      | c.hook_into :faraday  | faraday (w/ net_http) |
+      | c.hook_into :faraday  | faraday (w/ typhoeus) |
+

data/features/request_matching/uri_without_param.feature

@@ -0,0 +1,101 @@
+Feature: URI without param(s)
+
+  A common source of difficulty when using VCR with the default matchers
+  are non-deterministic URIs. If the URI changes on every test run (because
+  it includes a timestamp parameter, or whatever), the default URI matcher
+  will not work well for you.
+
+  You can write a custom matcher to match URIs however you want, but for the
+  common need to match on a URI and ignore particular query parameters, VCR
+  provides an easier way:
+
+      :match_requests_on => [
+        :method,
+        VCR.request_matchers.uri_without_param(:timestamp)
+      ]
+
+  `uri_without_param` also has a plural alias (i.e. `uri_without_params(:timestamp, :session)`)
+
+  Background:
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: get
+          uri: http://example.com/search?q=foo&timestamp=1316920490
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "12"
+          body: 
+            encoding: UTF-8
+            string: foo response
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      - request: 
+          method: get
+          uri: http://example.com/search?q=bar&timestamp=1296723437
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "12"
+          body: 
+            encoding: UTF-8
+            string: bar response
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
+      """
+
+  Scenario: Match the URI on all but the timestamp query parameter
+    And a file named "uri_without_param_matcher.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+        c.default_cassette_options = {
+          :match_requests_on => [:method,
+            VCR.request_matchers.uri_without_param(:timestamp)]
+        }
+      end
+
+      def search_uri(q)
+        "http://example.com/search?q=#{q}&timestamp=#{Time.now.to_i}"
+      end
+
+      VCR.use_cassette('example') do
+        puts "Response for bar: " +
+             response_body_for(:get, search_uri("bar"))
+      end
+
+      VCR.use_cassette('example') do
+        puts "Response for foo: " +
+             response_body_for(:get, search_uri("foo"))
+      end
+      """
+    When I run `ruby uri_without_param_matcher.rb`
+    Then it should pass with:
+      """
+      Response for bar: bar response
+      Response for foo: foo response
+      """
+

data/features/step_definitions/cli_steps.rb

@@ -0,0 +1,193 @@
+require 'vcr'
+require 'multi_json'
+
+module VCRHelpers
+
+  def normalize_cassette_hash(cassette_hash)
+    cassette_hash['recorded_with'] = "VCR #{VCR.version}"
+    cassette_hash['http_interactions'].map! { |h| normalize_http_interaction(h) }
+    cassette_hash
+  end
+
+  def normalize_headers(object)
+    object.headers = {} and return if object.headers.nil?
+    object.headers = {}.tap do |hash|
+      object.headers.each do |key, value|
+        hash[key.downcase] = value
+      end
+    end
+  end
+
+  def static_timestamp
+    @static_timestamp ||= Time.now
+  end
+
+  def normalize_http_interaction(hash)
+    VCR::HTTPInteraction.from_hash(hash).tap do |i|
+      normalize_headers(i.request)
+      normalize_headers(i.response)
+
+      i.recorded_at &&= static_timestamp
+      i.request.body ||= ''
+      i.response.body ||= ''
+      i.response.status.message ||= ''
+      i.response.adapter_metadata.clear
+
+      # Remove non-deterministic headers and headers
+      # that get added by a particular HTTP library (but not by others)
+      i.response.headers.reject! { |k, v| %w[ server date connection ].include?(k) }
+      i.request.headers.reject! { |k, v| %w[ accept user-agent connection expect date ].include?(k) }
+
+      # Some HTTP libraries include an extra space ("OK " instead of "OK")
+      i.response.status.message = i.response.status.message.strip
+
+      if @scenario_parameters.to_s =~ /excon|faraday/
+        # Excon/Faraday do not expose the status message or http version,
+        # so we have no way to record these attributes.
+        i.response.status.message = nil
+        i.response.http_version = nil
+      elsif @scenario_parameters.to_s.include?('webmock')
+        # WebMock does not expose the HTTP version so we have no way to record it
+        i.response.http_version = nil
+      end
+    end
+  end
+
+  def normalize_cassette_content(content)
+    return content unless @scenario_parameters.to_s.include?('patron')
+    cassette_hash = YAML.load(content)
+    cassette_hash['http_interactions'].map! do |hash|
+      VCR::HTTPInteraction.from_hash(hash).tap do |i|
+        i.request.headers = (i.request.headers || {}).merge!('Expect' => [''])
+      end.to_hash
+    end
+    YAML.dump(cassette_hash)
+  end
+
+  def modify_file(file_name, orig_text, new_text)
+    in_current_dir do
+      file = File.read(file_name)
+      regex = /#{Regexp.escape(orig_text)}/
+      file.should =~ regex
+
+      file = file.gsub(regex, new_text)
+      File.open(file_name, 'w') { |f| f.write(file) }
+    end
+  end
+end
+World(VCRHelpers)
+
+Given(/the following files do not exist:/) do |files|
+  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
+end
+
+Given(/^the directory "([^"]*)" does not exist$/) do |dir|
+  check_directory_presence([dir], false)
+end
+
+Given(/^a previously recorded cassette file "([^"]*)" with:$/) do |file_name, content|
+  write_file(file_name, normalize_cassette_content(content))
+end
+
+Given(/^it is (.*)$/) do |date_string|
+  set_env('DATE_STRING', date_string)
+end
+
+Given(/^that port numbers in "([^"]*)" are normalized to "([^"]*)"$/) do |file_name, port|
+  in_current_dir do
+    contents = File.read(file_name)
+    contents = contents.gsub(/:\d{2,}\//, ":#{port}/")
+    File.open(file_name, 'w') { |f| f.write(contents) }
+  end
+end
+
+When(/^I modify the file "([^"]*)" to replace "([^"]*)" with "([^"]*)"$/) do |file_name, orig_text, new_text|
+  modify_file(file_name, orig_text, new_text)
+end
+
+When(/^I append to file "([^"]*)":$/) do |file_name, content|
+  append_to_file(file_name, "\n" + content)
+end
+
+When(/^I set the "([^"]*)" environment variable to "([^"]*)"$/) do |var, value|
+  set_env(var, value)
+end
+
+Then(/^the file "([^"]*)" should exist$/) do |file_name|
+  check_file_presence([file_name], true)
+end
+
+Then(/^it should (pass|fail) with "([^"]*)"$/) do |pass_fail, partial_output|
+  assert_exit_status_and_partial_output(pass_fail == 'pass', partial_output)
+end
+
+Then(/^it should (pass|fail) with an error like:$/) do |pass_fail, partial_output|
+  assert_success(pass_fail == 'pass')
+
+  # different implementations place the exception class at different
+  # places relative to the message (i.e. with a multiline error message)
+  process_output = all_output.gsub(/\s*\(VCR::Errors::\w+\)/, '')
+
+  # Some implementations include extra leading spaces, for some reason...
+  process_output.gsub!(/^\s*/, '')
+  partial_output.gsub!(/^\s*/, '')
+
+  assert_partial_output(partial_output, process_output)
+end
+
+Then(/^the output should contain each of the following:$/) do |table|
+  table.raw.flatten.each do |string|
+    assert_partial_output(string, all_output)
+  end
+end
+
+Then(/^the file "([^"]*)" should contain YAML like:$/) do |file_name, expected_content|
+  actual_content = in_current_dir { File.read(file_name) }
+  normalize_cassette_hash(YAML.load(actual_content)).should == normalize_cassette_hash(YAML.load(expected_content))
+end
+
+Then(/^the file "([^"]*)" should contain JSON like:$/) do |file_name, expected_content|
+  actual_content = in_current_dir { File.read(file_name) }
+  actual = MultiJson.decode(actual_content)
+  expected = MultiJson.decode(expected_content)
+  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
+end
+
+Then(/^the file "([^"]*)" should contain ruby like:$/) do |file_name, expected_content|
+  actual_content = in_current_dir { File.read(file_name) }
+  actual = eval(actual_content)
+  expected = eval(expected_content)
+  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
+end
+
+Then(/^the file "([^"]*)" should contain each of these:$/) do |file_name, table|
+  table.raw.flatten.each do |string|
+    check_file_content(file_name, string, true)
+  end
+end
+
+Then(/^the file "([^"]*)" should contain a YAML fragment like:$/) do |file_name, fragment|
+  in_current_dir do
+    file_content = File.read(file_name)
+
+    # Normalize by removing leading and trailing whitespace...
+    file_content = file_content.split("\n").map do |line|
+      # Different versions of psych use single vs. double quotes
+      # And then 2.1 sometimes adds quotes...
+      line.strip.gsub('"', "'").gsub("'", '')
+    end.join("\n")
+
+    file_content.should include(fragment.gsub("'", ''))
+  end
+end
+
+Then(/^the cassette "([^"]*)" should have the following response bodies:$/) do |file, table|
+  interactions = in_current_dir { YAML.load_file(file) }['http_interactions'].map { |h| VCR::HTTPInteraction.from_hash(h) }
+  actual_response_bodies = interactions.map { |i| i.response.body }
+  expected_response_bodies = table.raw.flatten
+  actual_response_bodies.should =~ expected_response_bodies
+end
+
+Then(/^it should (pass|fail)$/) do |pass_fail|
+  assert_success(pass_fail == 'pass')
+end

data/features/support/env.rb

@@ -0,0 +1,44 @@
+require 'bundler'
+Bundler.setup
+
+ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+
+require 'aruba/cucumber'
+require 'aruba/jruby' if RUBY_PLATFORM == 'java'
+
+gem_specs = Bundler.load.specs
+load_paths = Dir.glob(gem_specs.map { |spec|
+  if spec.respond_to?(:lib_dirs_glob)
+    spec.lib_dirs_glob
+  else
+    spec.load_paths
+  end
+}.flatten)
+
+load_paths << File.expand_path("../../../spec", __FILE__)
+rubyopt = "-rsupport/cucumber_helpers"
+
+if RUBY_VERSION > '1.9'
+  load_paths.unshift(".")
+  rubyopt = "--disable-gems #{rubyopt}" if "ruby" == ruby_engine
+end
+
+Before do
+  @aruba_timeout_seconds = 30
+  if "jruby" == ruby_engine
+    @aruba_io_wait_seconds = 0.1
+  else
+    @aruba_io_wait_seconds = 0.02
+  end
+end
+
+Before("~@with-bundler") do
+  set_env("RUBYLIB", load_paths.join(":"))
+  set_env("RUBYOPT", rubyopt)
+end
+
+Before("@with-bundler") do
+  set_env("RUBYLIB", ".:#{ENV["RUBYLIB"]}:#{load_paths.last}")
+  set_env("RUBYOPT", "#{ENV["RUBYOPT"]} -rsupport/cucumber_helpers")
+end
+

data/features/support/http_lib_filters.rb

@@ -0,0 +1,53 @@
+# make the values of the example row cells available as an array...
+Cucumber::Ast::OutlineTable::ExampleRow.class_eval do
+  def cell_values
+    @cells.map { |c| c.value  }
+  end
+end
+
+if RUBY_VERSION == '1.8.7'
+  # We get timeouts on 1.8.7 w/ Patron for some reason.
+  UNSUPPORTED_HTTP_LIBS = %w[ patron ]
+elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  # Patron is freezing up the cukes (as it does on 1.9.2)
+
+  # I'm not sure why em-http-request isn't working on rbx,
+  # but considering the fact that VCR works with all the other
+  # libs just fine and doesn't do anything for em-http-request,
+  # it's probably a bug in it or rbx...so ignore it, for now.
+
+  # I'm getting errors in the curb C extension in rbx.
+
+  # Faraday and Typhoeus should be buildable on rbx, but the travis build times out,
+  # so we skip them to speed up the build on travis.
+  UNSUPPORTED_HTTP_LIBS = %w[ patron em-http-request curb faraday typhoeus ]
+elsif RUBY_PLATFORM == 'java'
+  # These gems have C extensions and can't install on JRuby.
+  c_dependent_libs = %w[ typhoeus patron curb em-http-request ]
+
+  # The latest version of httpclient seems to freeze up the cukes
+  # on JRuby.  I'm not sure why, and there's little benefit to running
+  # them on JRuby...so we just skip them.  Excon seems to have the same issue :(.
+  UNSUPPORTED_HTTP_LIBS = c_dependent_libs + %w[ httpclient excon ]
+end
+
+if defined?(UNSUPPORTED_HTTP_LIBS)
+  UNSUPPORTED_HTTP_LIB_REGEX = Regexp.union(*UNSUPPORTED_HTTP_LIBS)
+
+  # Filter out example rows that use libraries that are not supported on the current ruby interpreter
+  Around do |scenario, block|
+    unless scenario.respond_to?(:cell_values) && scenario.cell_values.any? { |v| v =~ UNSUPPORTED_HTTP_LIB_REGEX }
+      block.call
+    end
+  end
+end
+
+# Set a global based on the current stubbing lib so we can put special-case
+# logic in our step definitions based on the http stubbing library.
+Before do |scenario|
+  if scenario.respond_to?(:cell_values)
+    @scenario_parameters = scenario.cell_values
+  else
+    @scenario_parameters = nil
+  end
+end