mustwin-vcr 2.9.3

data/features/request_matching/README.md

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

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

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

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

data/features/request_matching/headers.feature

@@ -0,0 +1,85 @@
+Feature: Matching on Headers
+
+  Use the `:headers` request matcher to match requests on the request headers.
+
+  Scenario Outline: Replay interaction that matches the headers
+    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: ""
+          headers: 
+            X-User-Id: 
+            - "1"
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "15"
+          body: 
+            encoding: UTF-8
+            string: user 1 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: ""
+          headers: 
+            X-User-Id: 
+            - "2"
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "15"
+          body: 
+            encoding: UTF-8
+            string: user 2 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 "header_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 => [:headers]) do
+        puts "Response for user 2: " + response_body_for(:get, "http://example.com/", nil, 'X-User-Id' => '2')
+      end
+
+      VCR.use_cassette('example', :match_requests_on => [:headers]) do
+        puts "Response for user 1: " + response_body_for(:get, "http://example.com/", nil, 'X-User-Id' => '1')
+      end
+      """
+    When I run `ruby header_matching.rb`
+    Then it should pass with:
+      """
+      Response for user 2: user 2 response
+      Response for user 1: user 1 response
+      """
+
+    Examples:
+      | configuration         | http_lib              |
+      | c.hook_into :webmock  | curb                  |
+      | c.hook_into :webmock  | patron                |
+      | c.hook_into :webmock  | em-http-request       |
+

data/features/request_matching/host.feature

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