vcr 3.0.3 → 4.0.0

data/features/configuration/filter_sensitive_data.feature

@@ -1,153 +0,0 @@
-Feature: Filter sensitive data
-
-  Note: this config option is also available as `define_cassette_placeholder`
-  to reflect the fact that it is useful for more than just sensitive data.
-
-  The `filter_sensitive_data` configuration option can be used to prevent
-  sensitive data from being written to your cassette files.  This may be
-  important if you commit your cassettes files to source control and do
-  not want your sensitive data exposed.  Pass the following arguments to
-  `filter_sensitive_data`:
-
-    - A substitution string.  This is the string that will be written to
-      the cassettte file as a placeholder.  It should be unique and you
-      may want to wrap it in special characters like `{ }` or `< >`.
-    - A symbol specifying a tag (optional).  If a tag is given, the
-      filtering will only be applied to cassettes with the given tag.
-    - A block.  The block should return the sensitive text that you want
-      replaced with the substitution string.  If your block accepts an
-      argument, the HTTP interaction will be yielded so that you can
-      dynamically specify the sensitive text based on the interaction
-      (see the last scenario for an example of this).
-
-  When the interactions are replayed, the sensitive text will replace the
-  substitution string so that the interaction will be identical to what was
-  originally recorded.
-
-  You can specify as many filterings as you want.
-
-  Scenario: Multiple filterings
-    Given a file named "filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        $server = start_sinatra_app do
-          get('/') { "Hello World" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<GREETING>') { 'Hello' }
-        c.filter_sensitive_data('<LOCATION>') { 'World' }
-      end
-
-      VCR.use_cassette('filtering') do
-        response = Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby filtering.rb --with-server`
-    Then the output should contain "Response: Hello World"
-     And the file "cassettes/filtering.yml" should contain "<GREETING> <LOCATION>"
-     And the file "cassettes/filtering.yml" should not contain "Hello"
-     And the file "cassettes/filtering.yml" should not contain "World"
-
-    When I run `ruby filtering.rb`
-    Then the output should contain "Hello World"
-
-  Scenario: Filter tagged cassettes
-    Given a file named "tagged_filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        response_count = 0
-        $server = start_sinatra_app do
-          get('/') { "Hello World #{response_count += 1 }" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<LOCATION>', :my_tag) { 'World' }
-      end
-
-      VCR.use_cassette('tagged', :tag => :my_tag) do
-        response = Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0)
-        puts "Tagged Response: #{response.body}"
-      end
-
-      VCR.use_cassette('untagged', :record => :new_episodes) do
-        response = Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0)
-        puts "Untagged Response: #{response.body}"
-      end
-      """
-    When I run `ruby tagged_filtering.rb --with-server`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-     And the file "cassettes/tagged.yml" should contain "Hello <LOCATION> 1"
-     And the file "cassettes/untagged.yml" should contain "Hello World 2"
-
-    When I run `ruby tagged_filtering.rb`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-
-  Scenario: Filter dynamic data based on yielded HTTP interaction
-    Given a file named "dynamic_filtering.rb" with:
-      """ruby
-      include_http_adapter_for('net/http')
-
-      if ARGV.include?('--with-server')
-        $server = start_sinatra_app do
-          helpers do
-            def request_header_for(header_key_fragment)
-              key = env.keys.find { |k| k =~ /#{header_key_fragment}/i }
-              env[key]
-            end
-          end
-
-          get('/') { "#{request_header_for('username')}/#{request_header_for('password')}" }
-        end
-      end
-
-      require 'vcr'
-
-      USER_PASSWORDS = {
-        'john.doe' => 'monkey',
-        'jane.doe' => 'cheetah'
-      }
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<PASSWORD>') do |interaction|
-          USER_PASSWORDS[interaction.request.headers['X-Http-Username'].first]
-        end
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, :uri, :headers]) do
-        port = $server ? $server.port : 0
-        puts "Response: " + response_body_for(
-          :get, "http://localhost:#{port}/", nil,
-          'X-Http-Username' => 'john.doe',
-          'X-Http-Password' => USER_PASSWORDS['john.doe']
-        )
-      end
-      """
-    When I run `ruby dynamic_filtering.rb --with-server`
-    Then the output should contain "john.doe/monkey"
-    And the file "cassettes/example.yml" should contain "john.doe/<PASSWORD>"
-    And the file "cassettes/example.yml" should contain a YAML fragment like:
-      """
-      X-Http-Password:
-      - <PASSWORD>
-      """
-
-    When I run `ruby dynamic_filtering.rb`
-    Then the output should contain "john.doe/monkey"

data/features/configuration/hook_into.feature

@@ -1,172 +0,0 @@
-Feature: hook_into
-
-  The `hook_into` configuration option determines how VCR hooks into the
-  HTTP requests to record and replay them.  There are currently 4 valid
-  options which support many different HTTP libraries:
-
-    - :webmock can be used to hook into requests from:
-      - Net::HTTP
-      - HTTPClient
-      - Patron
-      - Curb (Curl::Easy, but not Curl::Multi)
-      - EM HTTP Request
-      - Typhoeus (Typhoeus::Hydra, but not Typhoeus::Easy or Typhoeus::Multi)
-      - Excon
-    - :typhoeus can be used to hook into itself (as long as you use Typhoeus::Hydra,
-      but not Typhoeus::Easy or Typhoeus::Multi).
-    - :excon can be used to hook into itself.
-    - :faraday can be used to hook into itself.
-    - :fakeweb (deprecated) can be used to hook into Net::HTTP requests.
-
-  There are some addiitonal trade offs to consider when deciding which
-  option to use:
-
-    - WebMock uses extensive monkey patching to hook into supported HTTP
-      libraries.  No monkey patching is used for Typhoeus, Excon or Faraday.
-    - Typhoeus, Excon, Faraday can be used together, and with either FakeWeb or WebMock.
-    - FakeWeb and WebMock cannot both be used at the same time.
-
-  Regardless of which library you use, VCR takes care of all of the configuration
-  for you.  You should not need to interact directly with FakeWeb, WebMock or the
-  stubbing facilities of Typhoeus, Excon or Faraday.  If/when you decide to change stubbing
-  libraries (i.e. if you initially use FakeWeb because it's faster but later need the
-  additional features of WebMock) you can change the `hook_into` configuration
-  option and it'll work with no other changes required.
-
-  Scenario Outline: Record and replay a request using each supported hook_into/http library combination
-    Given a file named "hook_into_http_lib_combo.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-      VCR.configure { |c| c.ignore_localhost = true }
-
-      $server = start_sinatra_app do
-        get('/') { ARGV[0] }
-      end
-
-      puts "The response for request 1 was: #{response_body_for(:get, "http://localhost:#{$server.port}/")}"
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'vcr_cassettes'
-        c.ignore_localhost = false
-        c.default_cassette_options = { :serialize_with => :syck }
-      end
-
-      VCR.use_cassette('example') do
-        puts "The response for request 2 was: #{response_body_for(:get, "http://localhost:#{$server.port}/")}"
-      end
-      """
-    When I run `ruby hook_into_http_lib_combo.rb 'Hello World'`
-    Then the output should contain each of the following:
-      | The response for request 1 was: Hello World |
-      | The response for request 2 was: Hello World |
-     And the file "vcr_cassettes/example.yml" should contain "Hello World"
-
-    When I run `ruby hook_into_http_lib_combo.rb 'Goodbye World'`
-    Then the output should contain each of the following:
-      | The response for request 1 was: Goodbye World |
-      | The response for request 2 was: Hello World   |
-     And the file "vcr_cassettes/example.yml" should contain "Hello World"
-
-   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 :webmock  | excon                 |
-      | 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) |
-
-  @exclude-jruby @exclude-rbx
-  Scenario Outline: Use Typhoeus, Excon and Faraday in combination with FakeWeb or WebMock
-    Given a file named "hook_into_multiple.rb" with:
-      """ruby
-      require 'typhoeus'
-      require 'excon'
-      require 'faraday'
-      require 'vcr'
-      <extra_require>
-
-      VCR.configure { |c| c.ignore_localhost = true }
-
-      $server = start_sinatra_app do
-        get('/:path') { "#{ARGV[0]} #{params[:path]}" }
-      end
-
-      def net_http_response
-        Net::HTTP.get_response('localhost', '/net_http', $server.port).body
-      end
-
-      def typhoeus_response
-        Typhoeus::Request.get("http://localhost:#{$server.port}/typhoeus").body
-      end
-
-      def excon_response
-        Excon.get("http://localhost:#{$server.port}/excon").body
-      end
-
-      def faraday_response
-        Faraday::Connection.new(:url => "http://localhost:#{$server.port}") do |builder|
-          builder.adapter :<faraday_adapter>
-        end.get('/faraday').body
-      end
-
-      puts "Net::HTTP 1: #{net_http_response}"
-      puts "Typhoeus 1: #{typhoeus_response}"
-      puts "Excon 1: #{excon_response}"
-      puts "Faraday 1: #{faraday_response}"
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>, :typhoeus, :excon, :faraday
-        c.cassette_library_dir = 'vcr_cassettes'
-        c.ignore_localhost = false
-      end
-
-      VCR.use_cassette('example') do
-        puts "Net::HTTP 2: #{net_http_response}"
-        puts "Typhoeus 2: #{typhoeus_response}"
-        puts "Excon 2: #{excon_response}"
-        puts "Faraday 2: #{faraday_response}"
-      end
-      """
-    When I run `ruby hook_into_multiple.rb 'Hello'`
-    Then the output should contain each of the following:
-      | Net::HTTP 1: Hello net_http |
-      | Typhoeus 1: Hello typhoeus  |
-      | Excon 1: Hello excon        |
-      | Faraday 1: Hello faraday    |
-      | Net::HTTP 2: Hello net_http |
-      | Typhoeus 2: Hello typhoeus  |
-      | Excon 2: Hello excon        |
-      | Faraday 2: Hello faraday    |
-    And the cassette "vcr_cassettes/example.yml" should have the following response bodies:
-      | Hello net_http |
-      | Hello typhoeus |
-      | Hello excon    |
-      | Hello faraday  |
-
-    When I run `ruby hook_into_multiple.rb 'Goodbye'`
-    Then the output should contain each of the following:
-      | Net::HTTP 1: Goodbye net_http |
-      | Typhoeus 1: Goodbye typhoeus  |
-      | Excon 1: Goodbye excon        |
-      | Faraday 1: Goodbye faraday    |
-      | Net::HTTP 2: Hello net_http   |
-      | Typhoeus 2: Hello typhoeus    |
-      | Excon 2: Hello excon          |
-      | Faraday 2: Hello faraday      |
-
-    Examples:
-      | hook_into | faraday_adapter | extra_require                       |
-      | :fakeweb  | net_http        |                                     |
-      | :webmock  | net_http        |                                     |
-      | :fakeweb  | typhoeus        | require 'typhoeus/adapters/faraday' |
-      | :webmock  | typhoeus        | require 'typhoeus/adapters/faraday' |

data/features/configuration/ignore_request.feature

@@ -1,192 +0,0 @@
-Feature: Ignore Request
-
-  By default, VCR hooks into every request, either allowing it and recording
-  it, or playing back a recorded response, or raising an error to force you
-  to deal with the new request.  In some situations, you may prefer to have
-  VCR ignore some requests.
-
-  VCR provides 3 configuration options to accomplish this:
-
-    * `ignore_request { |req| ... }` will ignore any request for which the
-      given block returns true.
-    * `ignore_hosts 'foo.com', 'bar.com'` allows you to specify particular
-      hosts to ignore.
-    * `ignore_localhost = true` is equivalent to `ignore_hosts 'localhost',
-      '127.0.0.1', '0.0.0.0'`. It is particularly useful for when you use
-      VCR with a javascript-enabled capybara driver, since capybara boots
-      your rack app and makes localhost requests to it to check that it has
-      booted.
-
-  Ignored requests are not recorded and are always allowed, regardless of
-  the record mode, and even outside of a `VCR.use_cassette` block.
-
-  Background:
-    Given a file named "sinatra_app.rb" with:
-      """ruby
-      response_count = 0
-      $server = start_sinatra_app do
-        get('/') { "Port 7777 Response #{response_count += 1}" }
-      end
-      """
-
-  @exclude-jruby
-  Scenario Outline: ignore requests to a specific port
-    Given a file named "ignore_request.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      response_count = 0
-      $server_8888 = start_sinatra_app do
-        get('/') { "Port 8888 Response #{response_count += 1}" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_request do |request|
-          URI(request.uri).port == $server.port
-        end
-
-        c.default_cassette_options = { :serialize_with => :syck }
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server_8888.port}/")
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      puts response_body_for(:get, "http://localhost:#{$server_8888.port}/")
-      """
-    When I run `ruby ignore_request.rb`
-    Then it should fail with an error like:
-      """
-      An HTTP request has been made that VCR does not know how to handle:
-      """
-     And the output should contain:
-      """
-      Port 8888 Response 1
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/example.yml" should contain "Port 8888"
-    And the file "cassettes/example.yml" should not contain "Port 7777"
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario Outline: ignored host requests are not recorded and are always allowed
-    Given a file named "ignore_hosts.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_hosts '127.0.0.1', 'localhost'
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby ignore_hosts.rb`
-    Then it should pass with:
-      """
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/example.yml" should not exist
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  @exclude-jruby
-  Scenario Outline: localhost requests are not treated differently by default
-    Given a file named "localhost_not_ignored.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = { :serialize_with => :syck }
-        <configuration>
-      end
-
-      VCR.use_cassette('localhost') do
-        response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby localhost_not_ignored.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-     And the file "cassettes/localhost.yml" should contain "Port 7777 Response 1"
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario Outline: localhost requests are allowed and not recorded when ignore_localhost = true
-    Given a file named "ignore_localhost_true.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_localhost = true
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('localhost') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby ignore_localhost_true.rb`
-    Then it should pass with:
-      """
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/localhost.yml" should not exist
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-