vcr 3.0.3 → 6.2.0

data/features/request_matching/host.feature

@@ -1,95 +0,0 @@
-Feature: Matching on Host
-
-  Use the `:host` request matcher to match requests on the request host.
-
-  You can use this (alone, or in combination with `:path`) as an
-  alternative to `:uri` so that non-deterministic portions of the URI
-  are not considered as part of the request matching.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://host1.com/some/long/path
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "14"
-          body: 
-            encoding: UTF-8
-            string: host1 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://host2.com/some/other/long/path
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "16"
-          body: 
-            encoding: UTF-8
-            string: host2 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 host
-    And a file named "host_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 => [:host]) do
-        puts "Response for host2: " + response_body_for(:get, "http://host2.com/home")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:host]) do
-        puts "Response for host1: " + response_body_for(:get,  "http://host1.com/about")
-      end
-      """
-    When I run `ruby host_matching.rb`
-    Then it should pass with:
-      """
-      Response for host2: host2 response
-      Response for host1: host1 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/identical_request_sequence.feature

@@ -1,89 +0,0 @@
-Feature: Identical requests are replayed in sequence
-
-  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.
-
-  Scenario Outline: identical requests are replayed in sequence
-    Given 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: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 1
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 2
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "rotate_responses.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') do
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-      end
-      """
-    When I run `ruby rotate_responses.rb`
-    Then it should pass with:
-      """
-      Response 1
-      Response 2
-      """
-
-    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/method.feature

@@ -1,96 +0,0 @@
-Feature: Matching on Method
-
-  Use the `:method` request matcher to match requests on the HTTP method
-  (i.e. GET, POST, PUT, DELETE, etc).  You will generally want to use
-  this matcher.
-
-  The `:method` matcher is used (along with the `:uri` matcher) by default
-  if you do not specify how requests should match.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://post-request.com/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "13"
-          body: 
-            encoding: UTF-8
-            string: post response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://get-request.com/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: get 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 HTTP method
-    And a file named "method_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 => [:method]) do
-        puts "Response for GET: " + response_body_for(:get, "http://example.com/")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method]) do
-        puts "Response for POST: " + response_body_for(:post,  "http://example.com/")
-      end
-      """
-    When I run `ruby method_matching.rb`
-    Then it should pass with:
-      """
-      Response for GET: get response
-      Response for POST: post 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/path.feature

@@ -1,96 +0,0 @@
-Feature: Matching on Path
-
-  Use the `:path` request matcher to match requests on the path portion
-  of the request URI.
-
-  You can use this (alone, or in combination with `:host`) as an
-  alternative to `:uri` so that non-deterministic portions of the URI
-  are not considered as part of the request matching.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://host1.com/about?date=2011-09-01
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "14"
-          body: 
-            encoding: UTF-8
-            string: about response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://host2.com/home?date=2011-09-01
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "15"
-          body: 
-            encoding: UTF-8
-            string: home 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 path
-    And a file named "path_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 => [:path]) do
-        puts "Response for /home: " + response_body_for(:get, "http://example.com/home")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:path]) do
-        puts "Response for /about: " + response_body_for(:get,  "http://example.com/about")
-      end
-      """
-    When I run `ruby path_matching.rb`
-    Then it should pass with:
-      """
-      Response for /home: home response
-      Response for /about: about 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/playback_repeats.feature

@@ -1,98 +0,0 @@
-Feature: Playback repeats
-
-  By default, each response in a cassette can only be matched and played back
-  once while the cassette is in use (it can, of course, be re-used in multiple
-  tests, each of which should use the cassette separately). Note that this is
-  a change from the behavior in VCR 1.x. The old behavior occurred because of
-  how FakeWeb and WebMock behave internally and was not intended. Repeats create
-  less accurate tests since the real HTTP server may not necessarily return the
-  same response when identical requests are made in sequence.
-
-  If you want to allow playback repeats, VCR has a cassette option for this:
-
-      :allow_playback_repeats => true
-
-  @exclude-jruby
-  Scenario: Responses do not repeat by default
-    Given 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: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 1
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 2
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "playback_repeats.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      puts "== With :allow_playback_repeats =="
-      VCR.use_cassette('example', :allow_playback_repeats => true) do
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-      end
-
-      puts "\n== Without :allow_playback_repeats =="
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-      end
-      """
-    When I run `ruby playback_repeats.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-     And the output should contain:
-      """
-      == With :allow_playback_repeats ==
-      Response 1
-      Response 2
-      Response 2
-
-      == Without :allow_playback_repeats ==
-      Response 1
-      Response 2
-      """

data/features/request_matching/query.feature

@@ -1,97 +0,0 @@
-Feature: Matching on Query string
-
-  Use the `:query` request matcher to match requests on the query string
-  portion of the request URI.
-
-  You can use this (alone, or in combination with others) as an
-  alternative to `:uri` so that non-deterministic portions of the URI
-  are not considered as part of the request matching.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: post
-          uri: http://host1.com/query?date=2011-09-01
-          body:
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "19"
-          body:
-            encoding: UTF-8
-            string: 2011-09-01 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request:
-          method: post
-          uri: http://host1.com/query?date=2011-09-02
-          body:
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "19"
-          body:
-            encoding: UTF-8
-            string: 2011-09-02 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 query string
-    And a file named "query_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.default_cassette_options = { :match_requests_on => [:query] }
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:query]) do
-        puts "Response for 2011-09-01 /query: " + response_body_for(:get, "http://example.com/query?date=2011-09-01")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:query]) do
-        puts "Response for 2011-09-02 /query: " + response_body_for(:get,  "http://example.com/query?date=2011-09-02")
-      end
-      """
-    When I run `ruby query_matching.rb`
-    Then it should pass with:
-      """
-      Response for 2011-09-01 /query: 2011-09-01 response
-      Response for 2011-09-02 /query: 2011-09-02 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/uri.feature

@@ -1,94 +0,0 @@
-Feature: Matching on URI
-
-  Use the `:uri` request matcher to match requests on the request URI.
-
-  The `:uri` matcher is used (along with the `:method` matcher) by default
-  if you do not specify how requests should match.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: foo response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://example.com/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: bar 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 request URI
-    And a file named "uri_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 => [:uri]) do
-        puts "Response for /bar: " + response_body_for(:get, "http://example.com/bar")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:uri]) do
-        puts "Response for /foo: " + response_body_for(:get,  "http://example.com/foo")
-      end
-      """
-    When I run `ruby uri_matching.rb`
-    Then it should pass with:
-      """
-      Response for /bar: bar response
-      Response for /foo: foo 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) |
-