mustwin-vcr 2.9.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b144a01a758a27441ff9dc981d618fd557a4c89
+  data.tar.gz: e6d176c3f3914df9ebf8e717ca15fb64434fff33
+SHA512:
+  metadata.gz: 83fa8d42a298514334b709f54730c7c25afb1767872fd2823d0506a59c309ba667437c8fe490b7071bd6ea77f90c7a5c64d6752bdb0a54f1ec9f06da8708e8ec
+  data.tar.gz: 6b5237e7020d77003dcc88639fc4325a603334eb353b91171755f2d035c976aeeb461484ae6c6b18dba63b94534fbe218ddd3ba416ec62e485cc3189226f5699

data/features/about_these_examples.md

@@ -0,0 +1,18 @@
+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 `vcr_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

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

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

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

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

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