vcr 3.0.3 → 4.0.0

data/features/record_modes/none.feature

@@ -1,72 +0,0 @@
-Feature: :none
-
-  The `:none` record mode will:
-
-    - Replay previously recorded interactions.
-    - Cause an error to be raised for any new requests.
-
-  This is useful when your code makes potentially dangerous
-  HTTP requests.  The `:none` record mode guarantees that no
-  new HTTP requests will be made.
-
-  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: Previously recorded responses are replayed
-    Given a file named "replay_recorded_response.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette('example', :record => :none) do
-        response = Net::HTTP.get_response('example.com', '/foo')
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby replay_recorded_response.rb`
-    Then it should pass with "Response: Hello"
-
-  @exclude-jruby
-  Scenario: New requests are prevented
-    Given a file named "prevent_new_request.rb" with:
-      """ruby
-      require 'vcr_config'
-
-      VCR.use_cassette('example', :record => :none) do
-        Net::HTTP.get_response('example.com', '/bar')
-      end
-      """
-    When I run `ruby prevent_new_request.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"

data/features/record_modes/once.feature

@@ -1,95 +0,0 @@
-Feature: :once
-
-  The `:once` record mode will:
-
-    - Replay previously recorded interactions.
-    - Record new interactions if there is no cassette file.
-    - Cause an error to be raised for new requests if there is a cassette file.
-
-  It is similar to the `:new_episodes` record mode, but will prevent new,
-  unexpected requests from being made (i.e. because the request URI changed
-  or whatever).
-
-  `:once` is the default record mode, used when you do not set one.
-
-  Background:
-    Given a file named "setup.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { 'Hello' }
-      end
-
-      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: 
-            - "20"
-          body: 
-            encoding: UTF-8
-            string: example.com response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario: Previously recorded responses are replayed
-    Given a file named "replay_recorded_response.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('example', :record => :once) do
-        response = Net::HTTP.get_response('example.com', '/foo')
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby replay_recorded_response.rb`
-    Then it should pass with "Response: example.com response"
-
-  @exclude-jruby
-  Scenario: New requests result in an error when the cassette file exists
-    Given a file named "error_for_new_requests_when_cassette_exists.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('example', :record => :once) do
-        response = Net::HTTP.get_response('localhost', '/', $server.port)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby error_for_new_requests_when_cassette_exists.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-
-  Scenario: New requests get recorded when there is no cassette file
-    Given a file named "record_new_requests.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('example', :record => :once) do
-        response = Net::HTTP.get_response('localhost', '/', $server.port)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I remove the file "cassettes/example.yml"
-    And I run `ruby record_new_requests.rb`
-    Then it should pass with "Response: Hello"
-    And the file "cassettes/example.yml" should contain "Hello"

data/features/request_matching/README.md

@@ -1,30 +0,0 @@
-In order to properly replay previously recorded requests, VCR must match new
-HTTP requests to a previously recorded one. By default, it matches on HTTP
-method and URI, since that is usually deterministic and fully identifies the
-resource and action for typical RESTful APIs.
-
-You can customize how VCR matches requests using the `:match_requests_on` cassette option.
-Specify an array of attributes to match on.  Supported attributes are:
-
-  - `:method` - The HTTP method (i.e. GET, POST, PUT or DELETE) of the request.
-  - `:uri` - The full URI of the request.
-  - `:host` - The host of the URI. You can use this (alone, or in combination
-    with `:path`) as an alternative to `:uri` to cause VCR to match using a regex
-    that matches the host.
-  - `:path` - The path of the URI. You can use this (alone, or in combination
-    with `:host`) as an alternative to `:uri` to cause VCR to match using a regex
-    that matches the path.
-  - `:query` - The query string values of the URI. The query string ordering does
-    not affect matching results (it's order-agnostic).
-  - `:body` - The body of the request.
-  - `:headers` - The request headers.
-
-You can also register a custom request matcher. This particularly comes
-in handy for dealing with APIs that use non-deterministic URIs (i.e. by
-including a timestamp as a query parameter or whatever).
-
-When a cassette contains multiple HTTP interactions that match a request
-based on the configured `:match_requests_on` setting, the responses are
-sequenced: the first matching request will get the first response,
-the second matching request will get the second response, etc.
-

data/features/request_matching/body.feature

@@ -1,91 +0,0 @@
-Feature: Matching on Body
-
-  Use the `:body` request matcher to match requests on the request body.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://example.net/some/long/path
-          body: 
-            encoding: UTF-8
-            string: body1
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "14"
-          body: 
-            encoding: UTF-8
-            string: body1 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://example.net/some/long/path
-          body: 
-            encoding: UTF-8
-            string: body2
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "14"
-          body: 
-            encoding: UTF-8
-            string: body2 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Replay interaction that matches the body
-    And a file named "body_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:body]) do
-        puts "Response for body2: " + response_body_for(:put, "http://example.com/", "body2")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:body]) do
-        puts "Response for body1: " + response_body_for(:put, "http://example.com/", "body1")
-      end
-      """
-    When I run `ruby body_matching.rb`
-    Then it should pass with:
-      """
-      Response for body2: body2 response
-      Response for body1: body1 response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |
-

data/features/request_matching/body_as_json.feature

@@ -1,90 +0,0 @@
-Feature: Matching on Body
-
-  Use the `:body_as_json` request matcher to match requests on the request body where the body is JSON.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: post
-          uri: http://example.net/some/long/path
-          body:
-            encoding: UTF-8
-            string: '{ "a" : "1" }'
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "14"
-          body:
-            encoding: UTF-8
-            string: body1 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request:
-          method: post
-          uri: http://example.net/some/long/path
-          body:
-            encoding: UTF-8
-            string: '{ "a" : "1", "b" : "2" }'
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "14"
-          body:
-            encoding: UTF-8
-            string: body2 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Replay interaction that matches the body as JSON
-    And a file named "body_as_json_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:body_as_json]) do
-        puts "Response for body as json 2: " + response_body_for(:put, "http://example.com/", '{ "a" : "1", "b" : "2" }')
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:body_as_json]) do
-        puts "Response for body as json 1: " + response_body_for(:put, "http://example.com/", '{ "a" : "1" }')
-      end
-      """
-    When I run `ruby body_as_json_matching.rb`
-    Then it should pass with:
-      """
-      Response for body as json 2: body2 response
-      Response for body as json 1: body1 response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |

data/features/request_matching/custom_matcher.feature

@@ -1,135 +0,0 @@
-Feature: Register and use a custom matcher
-
-  If the built-in matchers do not meet your needs, you can use a custom matcher.
-
-  Any 2-argument callable (that is, an object that responds to #call and accepts
-  2 arguments) can be a matcher.  Simply put the callable in your
-  `:match_requests_on` array.
-
-  In addition, you can register a named custom matcher with VCR, and use
-  the name in your `:match_requests_on` array.
-
-  Either way, your custom matcher should return a truthy value if the
-  given requests should be considered equivalent.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://foo.com:9000/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: port 9000 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://foo.com:8000/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: port 8000 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Use a callable as a custom request matcher
-    And a file named "callable_matcher.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      port_matcher = lambda do |request_1, request_2|
-        URI(request_1.uri).port == URI(request_2.uri).port
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, port_matcher]) do
-        puts "Response for port 8000: " + response_body_for(:get, "http://example.com:8000/")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, port_matcher]) do
-        puts "Response for port 9000: " + response_body_for(:get, "http://example.com:9000/")
-      end
-      """
-    When I run `ruby callable_matcher.rb`
-    Then it should pass with:
-      """
-      Response for port 8000: port 8000 response
-      Response for port 9000: port 9000 response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |
-
-  Scenario: Register a named custom matcher
-    And a file named "register_custom_matcher.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.register_request_matcher :port do |request_1, request_2|
-          URI(request_1.uri).port == URI(request_2.uri).port
-        end
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, :port]) do
-        puts "Response for port 8000: " + response_body_for(:get, "http://example.com:8000/")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, :port]) do
-        puts "Response for port 9000: " + response_body_for(:get, "http://example.com:9000/")
-      end
-      """
-    When I run `ruby register_custom_matcher.rb`
-    Then it should pass with:
-      """
-      Response for port 8000: port 8000 response
-      Response for port 9000: port 9000 response
-      """
-