vcr 1.3.1 → 1.3.2

data/features/step_definitions/cli_steps.rb

@@ -0,0 +1,82 @@
+require 'vcr/structs'
+
+module VCRHelpers
+  YAML_REGEX_FOR_1_9_1 = Regexp.union(*[
+    '  request',
+    '    method',
+    '    uri',
+    '    body',
+    '    headers',
+    '  response',
+    '    status',
+    '      code',
+    '      message',
+    '    body',
+    '    http_version'
+  ].uniq)
+
+  def normalize_cassette_yaml(content)
+    return content unless RUBY_VERSION == '1.9.1'
+
+    # Ruby 1.9.1 serializes YAML a bit different, so
+    # we deal with that difference and add leading colons here.
+    content = content.gsub(YAML_REGEX_FOR_1_9_1) do |match|
+      match.sub(/^ +/, '\0:')
+    end
+  end
+
+  def normalize_cassette_structs(content)
+    content = normalize_cassette_yaml(content)
+    structs = YAML.load(content)
+
+    # Remove non-deterministic headers
+    structs.each do |s|
+      s.response.headers.reject! { |k, v| %w[ server date ].include?(k) }
+    end
+
+    structs
+  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
+
+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 /^the output should contain each of the following:$/ do |table|
+  table.raw.flatten.each do |string|
+    assert_partial_output(string)
+  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_structs(actual_content).should == normalize_cassette_structs(expected_content)
+end
+
+Given /^a previously recorded cassette file "([^"]*)" with:$/ do |file_name, content|
+  create_file(file_name, normalize_cassette_yaml(content))
+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
+
+Given /^(\d+) days have passed since the cassette was recorded$/ do |day_count|
+  set_env('DAYS_PASSED', day_count)
+end
+

data/features/support/aruba_workaround/aruba_patches.rb

@@ -0,0 +1,36 @@
+# Aruba::Api#run in aruba 0.2.4 does not work w/ JRuby or Rubinius.
+# This is the version from 0.2.2 before aruba relied upon
+# BackgroundProcess (which is not jruby/rbx compatible).
+require 'tempfile'
+
+Aruba::Api.module_eval do
+  def run(cmd, fail_on_error=true)
+    cmd = detect_ruby(cmd)
+
+    stderr_file = Tempfile.new('cucumber')
+    stderr_file.close
+    in_current_dir do
+      announce_or_puts("$ cd #{Dir.pwd}") if @announce_dir
+      announce_or_puts("$ #{cmd}") if @announce_cmd
+
+      mode = RUBY_VERSION =~ /^1\.9/ ? {:external_encoding=>"UTF-8"} : 'r'
+      
+      IO.popen("#{cmd} 2> #{stderr_file.path}", mode) do |io|
+        @last_stdout = io.read
+        announce_or_puts(@last_stdout) if @announce_stdout
+      end
+
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+
+    announce_or_puts(@last_stderr) if @announce_stderr
+
+    if(@last_exit_status != 0 && fail_on_error)
+      fail("Exit status was #{@last_exit_status}. Output:\n#{combined_output}")
+    end
+
+    @last_stderr
+  end
+end
+

data/features/support/aruba_workaround/background_process.rb

@@ -0,0 +1,4 @@
+# Don't do anything--this is just here to allow aruba to run on JRuby/rbx.
+# It requires background_process, but that doesn't work on JRuby/rbx.
+# So on JRuby/rbx, we add this file's dir to the load path, in order to fake out aruba
+# and force it to load this file instaed.

data/features/support/env.rb

@@ -1,116 +1,30 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../spec/support')
-
-if ENV['HTTP_STUBBING_ADAPTER'].to_s == ''
-  ENV['HTTP_STUBBING_ADAPTER'] = 'fakeweb'
-  warn "Using FakeWeb for VCR's cucumber features since the adapter was not specified.  Set HTTP_STUBBING_ADAPTER to specify."
-end
-
-if ENV['HTTP_LIB'].to_s == ''
-  ENV['HTTP_LIB'] = 'net/http'
-  warn "Using Net::HTTP for VCR's cucumber features since the HTTP library was not specified.  Set HTTP_LIB to specify."
-end
-
-# The HTTP library must be loaded before VCR since WebMock looks for the presence of the HTTB library class constant
-# to decide whether or not to hook into it.
-require ENV['HTTP_LIB']
-require 'http_library_adapters'
-World(HTTP_LIBRARY_ADAPTERS[ENV['HTTP_LIB']])
-
-puts "\n\n---------------- Running features using #{ENV['HTTP_STUBBING_ADAPTER']} and #{ENV['HTTP_LIB']} -----------------\n"
-
-require 'vcr'
-require 'ruby_interpreter'
-require 'vcr_localhost_server'
-require 'fixnum_extension'
-
 require 'rubygems'
 require 'bundler'
 Bundler.setup
 
-require 'aruba'
-require 'timecop'
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-  Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
-rescue LoadError
-  # ruby-debug wasn't available so neither can the debugging be
-end unless RUBY_VERSION > '1.9.1' # ruby-debug doesn't work on 1.9.2 yet
-
-# Ruby 1.9.1 has a different yaml serialization format.
-YAML_SERIALIZATION_VERSION = RUBY_VERSION == '1.9.1' ? '1.9.1' : 'not_1.9.1'
-
-VCR.config do |c|
-  c.cassette_library_dir = File.join(File.dirname(__FILE__), '..', 'fixtures', 'vcr_cassettes', YAML_SERIALIZATION_VERSION)
+# Current version of aruba won't run on JRuby or Rubinius due to
+# dependency on background_process.  We have a work around to fix this.
+NEEDS_ARUBA_FIX = defined?(RUBY_ENGINE) && %w[ jruby rbx ].include?(RUBY_ENGINE)
 
-  stubs = [ENV['HTTP_STUBBING_ADAPTER'].to_sym, :typhoeus].uniq
-  stubs.delete(:typhoeus) if RUBY_INTERPRETER == :jruby
-
-  c.stub_with *stubs
-end
-
-VCR.module_eval do
-  def self.completed_cucumber_scenarios
-    @completed_cucumber_scenarios ||= []
-  end
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/aruba_workaround' if NEEDS_ARUBA_FIX
 
-  class << self
-    attr_accessor :current_cucumber_scenario
-  end
-end
-
-After do |scenario|
-  Timecop.return
-  if raised_error = (@http_requests || {}).values.flatten.detect { |result| result.is_a?(Exception) && result.message !~ /VCR/ }
-    raise raised_error
-  end
-  VCR.completed_cucumber_scenarios << scenario
-end
-
-Before do |scenario|
-  VCR::Config.ignore_localhost = false
-
-  VCR.current_cucumber_scenario = scenario
-  temp_dir = File.join(VCR::Config.cassette_library_dir, 'temp')
-  FileUtils.rm_rf(temp_dir) if File.exist?(temp_dir)
-end
+require 'aruba'
+require 'aruba_patches' if NEEDS_ARUBA_FIX
 
-%w[not_the_real_response record_all].each do |cassette|
-  Before("@copy_#{cassette}_to_temp") do
-    orig_file = File.join(VCR::Config.cassette_library_dir, "#{cassette}.yml")
-    temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', "#{cassette}.yml")
-    FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
-    FileUtils.cp orig_file, temp_file
+Before do
+  this_dir = File.dirname(__FILE__)
+  in_current_dir do
+    FileUtils.ln_s File.join(this_dir, 'vcr_cucumber_helpers.rb'), 'vcr_cucumber_helpers.rb'
   end
 end
 
-Before('@create_replay_localhost_cassette') do
-  orig_file = File.join(VCR::Config.cassette_library_dir, 'replay_localhost_cassette.yml')
-  temp_file = File.join(VCR::Config.cassette_library_dir, 'temp', 'replay_localhost_cassette.yml')
-  FileUtils.mkdir_p(File.join(VCR::Config.cassette_library_dir, 'temp'))
-
-  # the port varies each time, so create a temp cassette with the correct port.
-  port = static_rack_server('localhost response').port
-
-  interactions = YAML.load(File.read(orig_file))
-  interactions.each do |i|
-    uri = URI.parse(i.request.uri)
-    uri.port = port
-    i.request.uri = uri.to_s
+if RUBY_VERSION > '1.9.1'
+  Before do
+    set_env('RUBYOPT', '-I.:../../lib')
   end
-
-  File.open(temp_file, 'w') { |f| f.write interactions.to_yaml }
-end
-
-at_exit do
-  %w(record_cassette1 record_cassette2).each do |tag|
-    file = File.join(VCR::Config.cassette_library_dir, 'cucumber_tags', "#{tag}.yml")
-    FileUtils.rm_rf(file) if File.exist?(file)
+elsif RUBY_PLATFORM == 'java'
+  Before do
+    set_env('RUBYOPT', '-I../../lib -rubygems')
   end
 end
 
-VCR.cucumber_tags do |t|
-  t.tags '@record_cassette1', '@record_cassette2', :record => :new_episodes
-  t.tags '@replay_cassette1', '@replay_cassette2', '@replay_cassette3', '@regex_cassette', :record => :none
-end

data/features/support/http_lib_filters.rb

@@ -0,0 +1,37 @@
+# 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.9.2'
+  # For some reason, the local sinatra server locks up and never exits
+  # when using patron on 1.9.2, even though it exits fine during the specs.
+  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.
+  UNSUPPORTED_HTTP_LIBS = %w[ patron em-http-request curb ]
+elsif RUBY_PLATFORM == 'java'
+  # These gems have C extensions and can't install on JRuby.
+  UNSUPPORTED_HTTP_LIBS = %w[ typhoeus patron curb em-http-request ]
+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
+

data/features/support/vcr_cucumber_helpers.rb

@@ -0,0 +1,34 @@
+# This file gets symlinked into the tmp/aruba directory before
+# each scenario so that it is available to be required in them.
+$LOAD_PATH.unshift '../../spec' unless $LOAD_PATH.include?('../../spec')
+$LOAD_PATH.unshift '../../lib'  unless $LOAD_PATH.include?('../../lib')
+
+RUNNING_UNDER_ARUBA = File.dirname(__FILE__) == '.' || File.dirname(__FILE__) =~ /aruba/
+
+require 'support/fixnum_extension' if RUNNING_UNDER_ARUBA
+
+if ENV['DAYS_PASSED']
+  require 'timecop'
+  Timecop.travel(Time.now + ENV['DAYS_PASSED'].to_i.days)
+end
+
+def include_http_adapter_for(lib)
+  require 'support/http_library_adapters'
+  require lib
+  include HTTP_LIBRARY_ADAPTERS[lib]
+end
+
+def response_body_for(*args)
+  get_body_string(make_http_request(*args))
+end
+
+def start_sinatra_app(options, &block)
+  raise ArgumentError.new("You must pass a port") unless options[:port]
+
+  require 'sinatra'
+  require 'support/vcr_localhost_server'
+  klass = Class.new(Sinatra::Base)
+  klass.class_eval(&block)
+
+  VCR::LocalhostServer.new(klass.new, options[:port])
+end

data/features/test_frameworks/cucumber.feature

@@ -0,0 +1,109 @@
+Feature: Usage with cucumber
+
+  VCR can be used with cucumber in two basic ways:
+
+    * Use `VCR.use_cassette` in a step definition.
+    * Use a `VCR.cucumber_tags` block to tell VCR to use a
+      cassette for a tagged scenario.
+
+  In a cucumber support file (e.g. features/support/vcr.rb), put code like this:
+
+    VCR.cucumber_tags do |t|
+      t.tag  '@tag1'
+      t.tags '@tag2', '@tag3'
+
+      t.tag  '@tag3', :cassette => :options
+      t.tags '@tag4, '@tag5', :cassette => :options
+    end
+
+  VCR will use a cassette named "cucumber_tags/<tag_name>" for scenarios
+  with each of these tags.  The configured default_cassette_options will
+  be used, or you can override specific options by passing a hash as the
+  last argument to #tag or #tags.
+
+  Scenario: Record HTTP interactions in a scenario by tagging it
+    Given a file named "features/support/vcr.rb" with:
+      """
+      require 'vcr_cucumber_helpers.rb'
+
+      if ENV['WITH_SERVER'] == 'true'
+        start_sinatra_app(:port => 7777) do
+          get('/:path') { "Hello #{params[:path]}" }
+        end
+      end
+
+      require 'vcr'
+
+      VCR.config do |c|
+        c.stub_with :webmock
+        c.cassette_library_dir     = 'features/cassettes'
+        c.default_cassette_options = { :record => :new_episodes }
+      end
+
+      VCR.cucumber_tags do |t|
+        t.tag  '@localhost_request' # uses default record mode since no options are given
+        t.tags '@disallowed_1', '@disallowed_2', :record => :none
+      end
+      """
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      require 'net/http'
+
+      When /^a request is made to "([^"]*)"$/ do |url|
+        @response = Net::HTTP.get_response(URI.parse(url))
+      end
+
+      When /^(.*) within a cassette named "([^"]*)"$/ do |step, cassette_name|
+        VCR.use_cassette(cassette_name) { When step }
+      end
+
+      Then /^the response should be "([^"]*)"$/ do |expected_response|
+        @response.body.should == expected_response
+      end
+      """
+    And a file named "features/vcr_example.feature" with:
+      """
+      Feature: VCR example
+
+        @localhost_request
+        Scenario: tagged scenario
+          When a request is made to "http://localhost:7777/localhost_request_1"
+          Then the response should be "Hello localhost_request_1"
+          When a request is made to "http://localhost:7777/nested_cassette" within a cassette named "nested_cassette"
+          Then the response should be "Hello nested_cassette"
+          When a request is made to "http://localhost:7777/localhost_request_2"
+          Then the response should be "Hello localhost_request_2"
+
+        @disallowed_1
+        Scenario: tagged scenario
+          When a request is made to "http://localhost:7777/allowed" within a cassette named "allowed"
+          Then the response should be "Hello allowed"
+          When a request is made to "http://localhost:7777/disallowed_1"
+
+        @disallowed_2
+        Scenario: tagged scenario
+          When a request is made to "http://localhost:7777/disallowed_2"
+      """
+    And the directory "features/cassettes" does not exist
+    When I run "cucumber WITH_SERVER=true features/vcr_example.feature"
+    Then it should fail with "3 scenarios (2 failed, 1 passed)"
+    And the output should contain each of the following:
+      | Real HTTP connections are disabled. Unregistered request: GET http://localhost:7777/disallowed_1 |
+      | Real HTTP connections are disabled. Unregistered request: GET http://localhost:7777/disallowed_2 |
+    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "body: Hello localhost_request_1"
+    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "body: Hello localhost_request_2"
+    And the file "features/cassettes/nested_cassette.yml" should contain "body: Hello nested_cassette"
+    And the file "features/cassettes/allowed.yml" should contain "body: Hello allowed"
+
+    # Run again without the server; we'll get the same responses because VCR
+    # will replay the recorded responses.
+    When I run "cucumber features/vcr_example.feature"
+    Then it should fail with "3 scenarios (2 failed, 1 passed)"
+    And the output should contain each of the following:
+      | Real HTTP connections are disabled. Unregistered request: GET http://localhost:7777/disallowed_1 |
+      | Real HTTP connections are disabled. Unregistered request: GET http://localhost:7777/disallowed_2 |
+    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "body: Hello localhost_request_1"
+    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "body: Hello localhost_request_2"
+    And the file "features/cassettes/nested_cassette.yml" should contain "body: Hello nested_cassette"
+    And the file "features/cassettes/allowed.yml" should contain "body: Hello allowed"
+

data/features/test_frameworks/rspec.feature

@@ -0,0 +1,110 @@
+Feature: Usage with RSpec
+
+  VCR provides a macro that makes it easy to use a VCR cassette for an RSpec
+  example group.  To use it, simply add `config.extend VCR::RSpec::Macros`
+  to your RSpec configuration block.
+
+  In any example group, add a `use_vcr_cassette` declaration to use a cassette
+  for that example group.  You can use this in a few different ways:
+
+    * use_vcr_cassette
+      * Infers a cassette name from the example group description (and parent
+        example group descriptions).
+      * Uses the default_cassette_options you have configured.
+    * use_vcr_cassette "Cassette Name"
+      * Uses the given cassette name.
+      * Uses the default_cassette_options you have configured.
+    * use_vcr_cassette :cassette => :options
+      * Infers a cassette name from the example group description (and parent
+        example group descriptions).
+      * Uses the provided cassette options (merged with the defaults).
+    * use_vcr_cassette "Cassette Name", :cassette => :options
+      * Uses the given cassette name.
+      * Uses the provided cassette options (merged with the defaults).
+
+  Background:
+    Given the following files do not exist:
+        | spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml |
+        | spec/cassettes/net_http_example.yml                                        |
+    And a file named "spec/sinatra_app.rb" with:
+      """
+      require 'vcr_cucumber_helpers'
+
+      start_sinatra_app(:port => 7777) do
+        get('/') { "Hello" }
+      end
+      """
+    And a file named "spec/vcr_example_spec.rb" with:
+      """
+      require 'spec_helper'
+
+      describe "VCR-RSpec integration" do
+        def make_http_request
+          Net::HTTP.get_response('localhost', '/', 7777).body
+        end
+
+        context "without an explicit cassette name" do
+          use_vcr_cassette
+
+          it 'records an http request' do
+            make_http_request.should == 'Hello'
+          end
+        end
+
+        context "with an explicit cassette name" do
+          use_vcr_cassette "net_http_example"
+
+          it 'records an http request' do
+            make_http_request.should == 'Hello'
+          end
+        end
+      end
+      """
+
+  Scenario: Use `use_vcr_cassette` macro with RSpec 2
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'sinatra_app'
+      require 'vcr'
+
+      VCR.config do |c|
+        c.cassette_library_dir     = 'spec/cassettes'
+        c.stub_with                :fakeweb
+        c.default_cassette_options = { :record => :new_episodes }
+      end
+
+      RSpec.configure do |c|
+        c.extend VCR::RSpec::Macros
+      end
+      """
+    When I run "rspec spec/vcr_example_spec.rb"
+    Then the output should contain "2 examples, 0 failures"
+     And the file "spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "body: Hello"
+     And the file "spec/cassettes/net_http_example.yml" should contain "body: Hello"
+
+  Scenario: Use `use_vcr_cassette` macro with RSpec 1
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      require 'sinatra_app'
+      $LOAD_PATH.unshift(File.join(%w[ .. .. vendor rspec-1 lib ]))
+
+      require 'spec'
+      require 'spec/autorun'
+
+      require 'vcr'
+
+      VCR.config do |c|
+        c.cassette_library_dir     = 'spec/cassettes'
+        c.stub_with                  :fakeweb
+        c.default_cassette_options = { :record => :new_episodes }
+      end
+
+      Spec::Runner.configure do |c|
+        c.extend VCR::RSpec::Macros
+      end
+      """
+    When I run "ruby -Ispec spec/vcr_example_spec.rb"
+    Then the output should contain "2 examples, 0 failures"
+     And the file "spec/cassettes/VCR-RSpec_integration/without_an_explicit_cassette_name.yml" should contain "body: Hello"
+     And the file "spec/cassettes/net_http_example.yml" should contain "body: Hello"
+