vcr 3.0.3 → 4.0.0

data/features/cassettes/naming.feature

@@ -1,28 +0,0 @@
-Feature: Naming
-
-  When inserting or using a cassette, the first argument is the cassette name.
-  You can use any string for the name.  If you use the default `:file_system`
-  storage backend, VCR will sanitize the string before using it as a file name,
-  so that it is a file-system friendly file name.
-
-  Scenario: Name sanitizing
-    Given a file named "name_sanitizing.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
-
-      VCR.use_cassette('Fee, Fi Fo Fum') do
-        Net::HTTP.get_response('localhost', '/', $server.port)
-      end
-      """
-     And the directory "cassettes" does not exist
-    When I run `ruby name_sanitizing.rb`
-    Then the file "cassettes/Fee_Fi_Fo_Fum.yml" should contain "Hello"

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
-      """