vcr 3.0.3 → 6.2.0

data/features/request_matching/uri_without_param.feature

@@ -1,101 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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)}/
-      expect(file).to match(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) }
-  expect(normalize_cassette_hash(YAML.load(actual_content))).to eq(normalize_cassette_hash(YAML.load(expected_content.to_s)))
-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.to_s)
-  expect(normalize_cassette_hash(actual)).to eq(normalize_cassette_hash(expected))
-end
-
-Then(/^the file "([^"]*)" should contain compressed YAML like:$/) do |file_name, expected_content|
-  actual_content = in_current_dir { File.read(file_name) }
-  unzipped_content = Zlib::Inflate.inflate(actual_content)
-  expect(normalize_cassette_hash(YAML.load(unzipped_content))).to eq(normalize_cassette_hash(YAML.load(expected_content.to_s)))
-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)
-  expect(normalize_cassette_hash(actual)).to eq(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")
-
-    expect(file_content).to 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
-  expect(actual_response_bodies).to match(expected_response_bodies)
-end
-
-Then(/^it should (pass|fail)$/) do |pass_fail|
-  assert_success(pass_fail == 'pass')
-end

data/features/support/env.rb

@@ -1,46 +0,0 @@
-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}" unless "rbx" == 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)
-  set_env("RBXOPT", "--disable-gems #{ENV["RBXOPT"]}") if "rbx" == ruby_engine
-  set_env("GEM_HOME", nil)
-end
-
-Before("@with-bundler") do
-  set_env("RUBYLIB", ".:#{ENV["RUBYLIB"]}:#{load_paths.last}")
-  set_env("RUBYOPT", "#{ENV["RUBYOPT"]} -rsupport/cucumber_helpers")
-  set_env("BUNDLE_GEMFILE", Bundler.default_gemfile.expand_path.to_s)
-end

data/features/support/http_lib_filters.rb

@@ -1,46 +0,0 @@
-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.
-
-  # 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 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
-  Before do |scenario|
-    if scenario.respond_to?(:cell_values) && scenario.cell_values.any? { |v| v =~ UNSUPPORTED_HTTP_LIB_REGEX }
-      scenario.skip_invoke!
-    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

data/features/test_frameworks/cucumber.feature

@@ -1,211 +0,0 @@
-@with-bundler
-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:
-
-  ``` ruby
-  VCR.cucumber_tags do |t|
-    t.tag  '@tag1'
-    t.tags '@tag2', '@tag3'
-
-    t.tag  '@tag3', :cassette => :options
-    t.tags '@tag4', '@tag5', :cassette => :options
-    t.tag  '@vcr', :use_scenario_name => true
-  end
-  ```
-
-  VCR will use a cassette named `cucumber_tags/<tag_name>` for scenarios
-  with each of these tags (Unless the `:use_scenario_name` option is provided. See below).
-  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`.
-
-  You can also have VCR name your cassettes automatically according to the feature
-  and scenario name by providing `:use_scenario_name => true` to `#tag` or `#tags`.
-  In this case, the cassette will be named `<feature_name>/<scenario_name>`.
-  For scenario outlines, VCR will record one cassette per row, and the cassettes
-  will be named `<feature_name>/<scenario_name>/<row_name>`.
-
-  @exclude-jruby
-  Scenario: Record HTTP interactions in a scenario by tagging it
-    Given a file named "lib/server.rb" with:
-      """ruby
-      if ENV['WITH_SERVER'] == 'true'
-        $server = start_sinatra_app do
-          get('/:path') { "Hello #{params[:path]}" }
-        end
-      end
-      """
-
-    Given a file named "features/support/vcr.rb" with:
-      """ruby
-      require "lib/server"
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir     = 'features/cassettes'
-        c.default_cassette_options = {
-          :match_requests_on => [:method, :host, :path]
-        }
-      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
-        t.tag  '@vcr', :use_scenario_name => true
-      end
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """ruby
-      require 'net/http'
-
-      When /^a request is made to "([^"]*)"$/ do |url|
-        uri = URI.parse(url)
-        uri.port = $server.port if $server
-        @response = Net::HTTP.get_response(uri)
-      end
-
-      When /^(.*) within a cassette named "([^"]*)"$/ do |step_name, cassette_name|
-        VCR.use_cassette(cassette_name) { step(step_name) }
-      end
-
-      Then /^the response should be "([^"]*)"$/ do |expected_response|
-        expect(@response.body).to eq(expected_response)
-      end
-      """
-    And a file named "features/vcr_example.feature" with:
-      """
-      Feature: VCR example
-
-        Note: Cucumber treats the pre-amble as part of the feature name. When
-        using the :use_scenario_name option, VCR will only use the first line
-        of the feature name as the directory for the cassette.
-
-        @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"
-
-        @vcr
-        Scenario: tagged scenario
-
-        Note: Like the feature pre-amble, Cucumber treats the scenario pre-amble
-        as part of the scenario name. When using the :use_scenario_name option,
-        VCR will only use the first line of the feature name as the directory
-        for the cassette.
-
-          When a request is made to "http://localhost:7777/localhost_request_1"
-          Then the response should be "Hello localhost_request_1"
-
-        @vcr
-        Scenario Outline: tagged scenario outline
-          When a request is made to "http://localhost:7777/localhost_request_1"
-          Then the response should be "Hello localhost_request_1"
-          Examples:
-            | key  | value |
-            | foo  | bar   |
-
-        @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 "5 scenarios (2 failed, 3 passed)"
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_2"
-    And the file "features/cassettes/nested_cassette.yml" should contain "Hello nested_cassette"
-    And the file "features/cassettes/allowed.yml" should contain "Hello allowed"
-    And the file "features/cassettes/VCR_example/tagged_scenario.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/VCR_example/tagged_scenario_outline/_foo_bar_.yml" should contain "Hello localhost_request_1"
-
-    # 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 "5 scenarios (2 failed, 3 passed)"
-    And the output should contain each of the following:
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_1                                          |
-      | An HTTP request has been made that VCR does not know how to handle:               |
-      |   GET http://localhost:7777/disallowed_2                                          |
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/cucumber_tags/localhost_request.yml" should contain "Hello localhost_request_2"
-    And the file "features/cassettes/nested_cassette.yml" should contain "Hello nested_cassette"
-    And the file "features/cassettes/allowed.yml" should contain "Hello allowed"
-    And the file "features/cassettes/VCR_example/tagged_scenario.yml" should contain "Hello localhost_request_1"
-    And the file "features/cassettes/VCR_example/tagged_scenario_outline/_foo_bar_.yml" should contain "Hello localhost_request_1"
-
-  Scenario: `:allow_unused_http_interactions => false` does not raise if the scenario already failed
-    Given a previously recorded cassette file "features/cassettes/cucumber_tags/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "5"
-          body: 
-            encoding: UTF-8
-            string: Hello
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "features/support/vcr.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'features/cassettes'
-      end
-
-      VCR.cucumber_tags do |t|
-        t.tag '@example', :allow_unused_http_interactions => false
-      end
-      """
-    And a file named "features/step_definitions/steps.rb" with:
-      """ruby
-      When /^the scenario fails$/ do
-        raise "boom"
-      end
-      """
-    And a file named "features/vcr_example.feature" with:
-      """
-      Feature:
-
-        @example
-        Scenario: tagged scenario
-          When the scenario fails
-      """
-    When I run `cucumber features/vcr_example.feature`
-    Then it should fail with "1 scenario (1 failed)"
-     And the output should contain "boom"
-     And the output should not contain "There are unused HTTP interactions"
-

data/features/test_frameworks/rspec_macro.feature

@@ -1,81 +0,0 @@
-@with-bundler
-Feature: Usage with RSpec macro
-
-  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:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { "Hello" }
-      end
-      """
-    And a file named "spec/vcr_example_spec.rb" with:
-      """ruby
-      require 'spec_helper'
-
-      describe "VCR-RSpec integration" do
-        def make_http_request
-          Net::HTTP.get_response('localhost', '/', $server.port).body
-        end
-
-        context "without an explicit cassette name" do
-          use_vcr_cassette
-
-          it 'records an http request' do
-            expect(make_http_request).to eq('Hello')
-          end
-        end
-
-        context "with an explicit cassette name" do
-          use_vcr_cassette "net_http_example"
-
-          it 'records an http request' do
-            expect(make_http_request).to eq('Hello')
-          end
-        end
-      end
-      """
-
-  Scenario: Use `use_vcr_cassette` macro with RSpec 2
-    Given a file named "spec/spec_helper.rb" with:
-      """ruby
-      require 'sinatra_app'
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'spec/cassettes'
-        c.hook_into :webmock
-      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 "Hello"
-     And the file "spec/cassettes/net_http_example.yml" should contain "Hello"