mustwin-vcr 2.9.3

data/features/cassettes/update_content_length_header.feature

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

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

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

@@ -0,0 +1,59 @@
+@exclude-18
+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

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

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