vcr 3.0.2 → 6.0.0

data/features/CONTRIBUTING.md

@@ -1 +0,0 @@
-/Users/tony/src/vcr/CONTRIBUTING.md

data/features/LICENSE.md

@@ -1 +0,0 @@
-/Users/tony/src/vcr/LICENSE

data/features/README.md

@@ -1 +0,0 @@
-/Users/tony/src/vcr/README.md

data/features/Upgrade.md

@@ -1 +0,0 @@
-/Users/tony/src/vcr/Upgrade.md

data/features/about_these_examples.md

@@ -1,18 +0,0 @@
-The cucumber features provided here demonstrate all of the major features of
-VCR.  These features are executable documentation for VCR.
-
-Many of the examples use one (or both) of these helper functions
-provided by `spec/support/cucumber_helpers.rb`:
-
-* `start_sinatra_app`: starts a sinatra application on the given port.
-  The server automatically shuts down when the ruby script ends.  Many
-  examples re-run the script without the sinatra server to demonstrate
-  the replaying of a recorded HTTP response.
-* `include_http_adapter_for`: includes a module that implements a common
-  HTTP interface for the given HTTP library.  The `response_body_for`
-  method will make an HTTP request using the given library.  This
-  allows scenarios to be run against each different supported HTTP
-  library.
-
-If you have ideas to clarify or improve any of these cucumber features,
-please submit an [issue](https://github.com/vcr/vcr/issues) or pull request.

data/features/cassettes/allow_unused_http_interactions.feature

@@ -1,100 +0,0 @@
-Feature: Allow Unused HTTP Interactions
-
-  If set to false, this cassette option will cause VCR to raise an error
-  when a cassette is ejected and there are unused HTTP interactions remaining,
-  unless there is already an exception unwinding the callstack.
-
-  It verifies that all requests included in the cassette were made, and allows
-  VCR to function a bit like a mock object at the HTTP layer.
-
-  The option defaults to true (mostly for backwards compatibility).
-
-  Background:
-    Given a file named "vcr_config.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-    And a previously recorded cassette file "cassettes/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
-      """
-
-  Scenario: Unused HTTP interactions are allowed by default
-    Given a file named "allowed_by_default.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette("example") do
-        # no requests
-      end
-      """
-    When I run `ruby allowed_by_default.rb`
-    Then it should pass
-
-  Scenario: Error raised if option is false and there are unused interactions
-    Given a file named "disallowed_with_no_requests.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette("example", :allow_unused_http_interactions => false) do
-        # no requests
-      end
-      """
-    When I run `ruby disallowed_with_no_requests.rb`
-    Then it should fail with an error like:
-      """
-      There are unused HTTP interactions left in the cassette:
-        - [get http://example.com/foo] => [200 "Hello"]
-      """
-
-  Scenario: No error raised if option is false and all interactions are used
-    Given a file named "disallowed_with_all_requests.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette("example", :allow_unused_http_interactions => false) do
-        Net::HTTP.get_response(URI("http://example.com/foo"))
-      end
-      """
-    When I run `ruby disallowed_with_all_requests.rb`
-    Then it should pass
-
-  Scenario: Does not silence other errors raised in `use_cassette` block
-    Given a file named "does_not_silence_other_errors.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette("example", :allow_unused_http_interactions => false) do
-        raise "boom"
-      end
-      """
-    When I run `ruby does_not_silence_other_errors.rb`
-    Then it should fail with "boom"
-     And the output should not contain "There are unused HTTP interactions"
-

data/features/cassettes/automatic_re_recording.feature

@@ -1,72 +0,0 @@
-Feature: Automatic Re-recording
-
-  Over time, your cassettes may get out-of-date. APIs change and sites you
-  scrape get updated. VCR provides a facility to automatically re-record your
-  cassettes. Enable re-recording using the `:re_record_interval` option.
-
-  The value provided should be an interval (expressed in seconds) that
-  determines how often VCR will re-record the cassette.  When a cassette
-  is used, VCR checks the earliest `recorded_at` timestamp in the cassette;
-  if more time than the interval has passed since that timestamp,
-  VCR will use the `:all` record mode to cause it be re-recorded.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: Old Response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "re_record.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { 'New Response' }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :re_record_interval => 7.days, :match_requests_on => [:method, :host, :path]) do
-        puts Net::HTTP.get_response('localhost', '/', $server.port).body
-      end
-      """
-
-  Scenario: Cassette is not re-recorded when not enough time has passed
-    Given it is Tue, 07 Nov 2011
-    When I run `ruby re_record.rb`
-    Then the output should contain "Old Response"
-    But the output should not contain "New Response"
-    And the file "cassettes/example.yml" should contain "Old Response"
-    But the file "cassettes/example.yml" should not contain "New Response"
-
-  Scenario: Cassette is re-recorded when enough time has passed
-    Given it is Tue, 09 Nov 2011
-    When I run `ruby re_record.rb`
-    Then the output should contain "New Response"
-    But the output should not contain "Old Response"
-    And the file "cassettes/example.yml" should contain "New Response"
-    But the file "cassettes/example.yml" should not contain "Old Response"
-

data/features/cassettes/decompress.feature

@@ -1,74 +0,0 @@
-Feature: Decode compressed response
-
-  When the `:decode_compressed_response` option is set to a truthy value, VCR
-  will decompress "gzip" and "deflate" response bodies before recording.  This
-  ensures that these interactions become readable and editable after being
-  serialized.
-
-  This option should be avoided if the actual decompression of response bodies
-  is part of the functionality of the library or app being tested.
-
-  Background:
-    Given a file named "decompress.rb" with:
-      """ruby
-      require 'zlib'
-      require 'stringio'
-
-      $server = start_sinatra_app do
-        get('/') {
-          content = 'The quick brown fox jumps over the lazy dog'
-          io = StringIO.new
-
-          writer = Zlib::GzipWriter.new(io)
-          writer << content
-          writer.close
-
-          headers['Content-Encoding'] = 'gzip'
-          io.string
-        }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-        c.default_cassette_options = { :serialize_with => :syck }
-      end
-      """
-
-  Scenario: The option is not set by default
-    When I append to file "decompress.rb":
-      """ruby
-      VCR.use_cassette(:decompress) do
-        Net::HTTP.start('localhost', $server.port) do |http|
-          http.get('/', 'accept-encoding' => 'identity')
-        end
-      end
-      """
-    And I run `ruby decompress.rb`
-    Then the file "cassettes/decompress.yml" should contain a YAML fragment like:
-      """
-      Content-Encoding:
-      - gzip
-      """
-
-  Scenario: The option is enabled
-    When I append to file "decompress.rb":
-      """ruby
-      VCR.use_cassette(:decompress, :decode_compressed_response => true) do
-        Net::HTTP.start('localhost', $server.port) do |http|
-          http.get('/', 'accept-encoding' => 'identity')
-        end
-      end
-      """
-    And I run `ruby decompress.rb`
-    Then the file "cassettes/decompress.yml" should contain a YAML fragment like:
-      """
-      Content-Length:
-      - '43'
-      """
-    And the file "cassettes/decompress.yml" should contain:
-      """
-      string: The quick brown fox jumps over the lazy dog
-      """

data/features/cassettes/dynamic_erb.feature

@@ -1,100 +0,0 @@
-Feature: Dynamic ERB cassettes
-
-  By default, cassettes are static: the exact response that was received
-  when the cassette was recorded will be replayed for all future requests.
-  Usually, this is fine, but in some cases you need something more dynamic.
-  You can use ERB for this.
-
-  To enable ERB evaluation of a cassette, pass the `:erb => true` option
-  to a cassette.  If you want to pass variables to the cassette, you can
-  pass the names and values of the variables in a hash (`:erb => { ... }`).
-
-  Scenario: Enable dynamic ERB cassette evalutation using :erb => true
-    Given a previously recorded cassette file "cassettes/dynamic.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: get
-          uri: http://example.com/foo?a=<%= 'b' * 3 %>
-          body:
-            encoding: UTF-8
-            string: ''
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Type:
-            - text/html;charset=utf-8
-            Content-Length:
-            - '9'
-          body:
-            encoding: UTF-8
-            string: Hello <%= 'bar'.next %>
-          http_version: '1.1'
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "dynamic_erb_example.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('dynamic', :erb => true) do
-        response = Net::HTTP.get_response('example.com', '/foo?a=bbb')
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby dynamic_erb_example.rb`
-    Then it should pass with "Response: Hello bas"
-
-  Scenario: Pass arguments to the ERB using :erb => { ... }
-    Given a previously recorded cassette file "cassettes/dynamic.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: get
-          uri: http://example.com/foo?a=<%= arg1 %>
-          body:
-            encoding: UTF-8
-            string: ''
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Type:
-            - text/html;charset=utf-8
-            Content-Length:
-            - '9'
-          body:
-            encoding: UTF-8
-            string: Hello <%= arg2 %>
-          http_version: '1.1'
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "dynamic_erb_example.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('dynamic', :erb => { :arg1 => 7, :arg2 => 'baz' }) do
-        response = Net::HTTP.get_response('example.com', '/foo?a=7')
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby dynamic_erb_example.rb`
-    Then it should pass with "Response: Hello baz"

data/features/cassettes/exclusive.feature

@@ -1,126 +0,0 @@
-Feature: exclusive cassette
-
-  VCR allows cassettes to be nested. This is particularly useful in
-  a context like cucumber, where you may be using a cassette for an
-  entire scenario, and also using a cassette within a particular step
-  definition.
-
-  By default, both the inner and outer cassettes are active. On each
-  request, VCR will look for a matching HTTP interaction in the inner
-  cassette, and it will use the outer cassette as a fall back if none
-  can be found.
-
-  If you do not want the HTTP interactions of the outer cassette considered,
-  you can pass the `:exclusive` option, so that the inner cassette is
-  used exclusively.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/outer.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/outer
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: Old outer response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a previously recorded cassette file "cassettes/inner.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/inner
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: Old inner response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "setup.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      $server = start_sinatra_app do
-        get('/:path') { "New #{params[:path]} response" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = {
-          :record => :new_episodes,
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-      """
-
-  Scenario: Cassettes are not exclusive by default
-    Given a file named "not_exclusive.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('outer') do
-        VCR.use_cassette('inner') do
-          puts response_body_for(:get, "http://localhost:#{$server.port}/outer")
-          puts response_body_for(:get, "http://localhost:#{$server.port}/inner")
-        end
-      end
-      """
-    When I run `ruby not_exclusive.rb`
-    Then it should pass with:
-      """
-      Old outer response
-      Old inner response
-      """
-
-  Scenario: Use an exclusive cassette
-    Given a file named "exclusive.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('outer') do
-        VCR.use_cassette('inner', :exclusive => true) do
-          puts response_body_for(:get, "http://localhost:#{$server.port}/outer")
-          puts response_body_for(:get, "http://localhost:#{$server.port}/inner")
-        end
-      end
-      """
-    When I run `ruby exclusive.rb`
-    Then it should pass with:
-      """
-      New outer response
-      Old inner response
-      """
-    And the file "cassettes/inner.yml" should contain "New outer response"
-