vcr 3.0.3 → 6.2.0

data/features/cassettes/no_cassette.feature

@@ -1,152 +0,0 @@
-Feature: Error for HTTP request made when no cassette is in use
-
-  VCR is designed to help you remove all HTTP dependencies from your
-  test suite.  To assist with this, VCR will cause an exception to be
-  raised when an HTTP request is made while there is no cassette in
-  use.  The error is helpful to pinpoint where HTTP requests are
-  made so you can use a VCR cassette at that point in your code.
-
-  If you want insight about how VCR attempted to handle the request,
-  you can use the [debug\_logger](../configuration/debug-logging)
-  configuration option to log more details.
-
-  If you want to allow an HTTP request to proceed as normal, you can
-  set the [allow\_http\_connections\_when\_no\_cassette](../configuration/allow-http-connections-when-no-cassette)
-  configuration option or you can temporarily turn VCR off:
-
-    - `VCR.turn_off!` => turn VCR off so HTTP requests are allowed.
-      Cassette insertions will trigger an error.
-    - `VCR.turn_off!(:ignore_cassettes => true)` => turn
-      VCR off and ignore cassette insertions (so that no error is raised).
-    - `VCR.turn_on!` => turn VCR back on
-    - `VCR.turned_off { ... }` => turn VCR off for the duration of the
-      provided block.
-
-  @exclude-jruby
-  Scenario Outline: Error for request when no cassette is in use
-    Given a file named "no_cassette_error.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      response_body_for(:get, 'http://example.com/')
-      """
-    When I run `ruby no_cassette_error.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-
-    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) |
-
-  Scenario: Temporarily turn VCR off to allow HTTP requests to procede as normal
-    Given a file named "turn_off_vcr.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { 'Hello' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      def make_request(context)
-        puts context
-        puts Net::HTTP.get_response('localhost', '/', $server.port).body
-      rescue => e
-        puts "Error: #{e.class}"
-      end
-
-      VCR.turned_off do
-        make_request "In VCR.turned_off block"
-      end
-
-      make_request "Outside of VCR.turned_off block"
-
-      VCR.turn_off!
-      make_request "After calling VCR.turn_off!"
-
-      VCR.turn_on!
-      make_request "After calling VCR.turn_on!"
-      """
-    When I run `ruby turn_off_vcr.rb`
-    Then the output should contain:
-      """
-      In VCR.turned_off block
-      Hello
-      """
-    And the output should contain:
-      """
-      Outside of VCR.turned_off block
-      Error: VCR::Errors::UnhandledHTTPRequestError
-      """
-    And the output should contain:
-      """
-      After calling VCR.turn_off!
-      Hello
-      """
-    And the output should contain:
-      """
-      After calling VCR.turn_on!
-      Error: VCR::Errors::UnhandledHTTPRequestError
-      """
-
-  Scenario: Turning VCR off prevents cassettes from being inserted
-    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      VCR.turn_off!
-      VCR.insert_cassette('example')
-      """
-    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
-    Then it should fail with "VCR is turned off.  You must turn it on before you can insert a cassette."
-
-  Scenario: Turning VCR off with `:ignore_cassettes => true` ignores cassettes
-    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { 'Hello' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-      WebMock.allow_net_connect!
-
-      VCR.turn_off!(:ignore_cassettes => true)
-
-      VCR.use_cassette('example') do
-        response = Net::HTTP.get_response('localhost', '/', $server.port).body
-        puts "Response: #{response}"
-      end
-      """
-    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
-    Then it should pass with "Response: Hello"
-     And the file "cassettes/example.yml" should not exist
-

data/features/cassettes/update_content_length_header.feature

@@ -1,112 +0,0 @@
-Feature: Update content_length header
-
-  When the `:update_content_length_header` option is set to a truthy value,
-  VCR will ensure that the `Content-Length` header will have the correct
-  value.  This is useful in several situations:
-
-    - When you manually edit the cassette file and change the resonse body
-      length.  You can use this option so you don't have to manually calculate
-      and update the body length.
-    - When you use ERB, the response body length may vary.  This will ensure
-      it is always correct.
-    - Syck, the default YAML engine for ruby 1.8 (and 1.9, unless you compile
-      it to use Psych), has a bug where it sometimes will remove some
-      whitespace strings when you serialize them.  This may cause the
-      `Content-Length` header to have the wrong value.
-
-  This is especially important when you use a client that checks the
-  `Content-Length` header.  Mechanize, for example, will raise an `EOFError`
-  when the header value does not match the actual body length.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "11"
-          body: 
-            encoding: UTF-8
-            string: Hello <modified>
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "common_stuff.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-
-      def make_request_and_print_results
-        response = Net::HTTP.get_response('example.com', '/')
-        puts "Body length: #{response.body.length}"
-        puts "Header value: #{response['Content-Length']}"
-      end
-      """
-
-  Scenario: Default :update_content_length_header setting
-    Given a file named "default.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example') do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby default.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => false
-    Given a file named "false.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => false) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby false.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => true
-    Given a file named "true.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => true) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby true.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 16
-      """
-

data/features/configuration/allow_http_connections_when_no_cassette.feature

@@ -1,55 +0,0 @@
-Feature: Allow HTTP connections when no cassette
-
-  Usually, HTTP requests made when no cassette is inserted will [result in an
-  error](../cassettes/error-for-http-request-made-when-no-cassette-is-in-use).
-  You can set the `allow_http_connections_when_no_cassette` configuration option
-  to true to allow requests, if you do not want to use VCR for everything.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        $server = start_sinatra_app do
-          get('/') { "Hello" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.allow_http_connections_when_no_cassette = true
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = {
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-      """
-    And the directory "vcr/cassettes" does not exist
-
-  Scenario: Allow HTTP connections when no cassette
-    Given a file named "no_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      puts "Response: " + Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0).body
-      """
-    When I run `ruby no_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-
-  Scenario: Cassettes record and replay as normal
-    Given a file named "record_replay_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('localhost') do
-        puts "Response: " + Net::HTTP.get_response('localhost', '/', $server ? $server.port : 0).body
-      end
-      """
-    When I run `ruby record_replay_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-    And the file "cassettes/localhost.yml" should contain "Hello"
-
-    When I run `ruby record_replay_cassette.rb`
-    Then the output should contain "Response: Hello"
-

data/features/configuration/cassette_library_dir.feature

@@ -1,31 +0,0 @@
-Feature: cassette_library_dir
-
-  The `cassette_library_dir` configuration option sets a directory
-  where VCR saves each cassette.
-
-  Note: When using Rails, avoid using the `test/fixtures` directory 
-  to store the cassettes. Rails treats any YAML file in the fixtures 
-  directory as an ActiveRecord fixture.
-  This will cause an `ActiveRecord::Fixture::FormatError` to be raised.
-
-  Scenario: cassette_library_dir
-    Given a file named "cassette_library_dir.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { "Hello" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'vcr/cassettes'
-        c.hook_into :webmock
-      end
-
-      VCR.use_cassette('localhost') do
-        Net::HTTP.get_response('localhost', '/', $server.port)
-      end
-      """
-     And the directory "vcr/cassettes" does not exist
-    When I run `ruby cassette_library_dir.rb`
-    Then the file "vcr/cassettes/localhost.yml" should exist

data/features/configuration/debug_logging.feature

@@ -1,58 +0,0 @@
-Feature: Debug Logging
-
-  Use the `debug_logger` option to set an IO-like object that VCR will log
-  debug output to. This is a useful way to troubleshoot what VCR is doing.
-
-  The debug logger must respond to `#puts`.
-
-  Scenario: Use the debug logger for troubleshooting
-    Given a file named "debug_logger.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.debug_logger = File.open(ARGV.first, 'w')
-        c.default_cassette_options = {
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-
-      VCR.use_cassette('example') do
-        port = $server ? $server.port : 7777
-        Net::HTTP.get_response(URI("http://localhost:#{port}/"))
-      end
-      """
-    When I run `ruby debug_logger.rb record.log --with-server`
-    Given that port numbers in "record.log" are normalized to "7777"
-    Then the file "record.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :host, :path], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :host, :path] and 0 interaction(s): {  }
-      [webmock] Identified request type (recordable) for [get http://localhost:7777/]
-      [Cassette: 'example'] Recorded HTTP interaction [get http://localhost:7777/] => [200 "Hello World"]
-
-      """
-    When I run `ruby debug_logger.rb playback.log`
-    Given that port numbers in "playback.log" are normalized to "7777"
-    Then the file "playback.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :host, :path], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :host, :path] and 1 interaction(s): { [get http://localhost:7777/] => [200 "Hello World"] }
-        [Cassette: 'example'] Checking if [get http://localhost:7777/] matches [get http://localhost:7777/] using [:method, :host, :path]
-          [Cassette: 'example'] method (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-          [Cassette: 'example'] host (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-          [Cassette: 'example'] path (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-        [Cassette: 'example'] Found matching interaction for [get http://localhost:7777/] at index 0: [200 "Hello World"]
-      [webmock] Identified request type (stubbed_by_vcr) for [get http://localhost:7777/]
-
-      """

data/features/configuration/default_cassette_options.feature

@@ -1,100 +0,0 @@
-Feature: default_cassette_options
-
-  The `default_cassette_options` configuration option takes a hash
-  that provides defaults for each cassette you use.  Any cassette
-  can override the defaults as well as set additional options.
-
-  The `:match_requests_on` option defaults to `[:method, :uri]` when
-  it has not been set.
-
-  The `:record` option defaults to `:once` when it has not been set.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.default_cassette_options = { :record => :new_episodes, :erb => true }
-
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-
-  Scenario: cassettes get default values from configured `default_cassette_options`
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: new_episodes
-      ERB: true
-      """
-
-  Scenario: `:match_requests_on` defaults to `[:method, :uri]` when it has not been set
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Match Requests On: #{VCR.current_cassette.match_requests_on.inspect}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Match Requests On: [:method, :uri]"
-
-  Scenario: `:record` defaults to `:once` when it has not been set
-    Given a file named "default_record_mode.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        puts "Record mode: #{VCR.current_cassette.record_mode.inspect}"
-      end
-      """
-    When I run `ruby default_record_mode.rb`
-    Then the output should contain "Record mode: :once"
-
-  Scenario: cassettes can set their own options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :re_record_interval => 10000) do
-        puts "Re-record Interval: #{VCR.current_cassette.re_record_interval}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Re-record Interval: 10000"
-
-  Scenario: cassettes can override default options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :record => :none, :erb => false) do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: none
-      ERB: false
-      """

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"