vcr 1.11.3 → 2.0.0.beta1

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.
+
+  Background:
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://example.net:80/some/long/path
+          body: 
+          headers: 
+            x-user-id: 
+            - "1"
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "15"
+          body: user 1 response
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://example.net:80/some/long/path
+          body: 
+          headers: 
+            x-user-id: 
+            - "2"
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "15"
+          body: user 2 response
+          http_version: "1.1"
+      """
+
+  Scenario Outline: Replay interaction that matches the headers
+    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 :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                 |
+      |                       | faraday (w/ net_http) |
+      |                       | faraday (w/ typhoeus) |
+

data/features/request_matching/host.feature

@@ -0,0 +1,85 @@
+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:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://host1.com:80/some/long/path
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "14"
+          body: host1 response
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://host2.com:80/some/other/long/path
+          body:
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "16"
+          body: host2 response
+          http_version: "1.1"
+      """
+
+  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                 |
+      |                       | faraday (w/ net_http) |
+      |                       | faraday (w/ typhoeus) |
+

data/features/request_matching/identical_request_sequence.feature

@@ -0,0 +1,79 @@
+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:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://example.com:80/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "10"
+          body: Response 1
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://example.com:80/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "10"
+          body: Response 2
+          http_version: "1.1"
+      """
+    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                 |
+      |                       | faraday (w/ net_http) |
+      |                       | faraday (w/ typhoeus) |
+

data/features/request_matching/method.feature

@@ -0,0 +1,86 @@
+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:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://post-request.com:80/
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "13"
+          body: post response
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://get-request.com:80/
+          body:
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "12"
+          body: get response
+          http_version: "1.1"
+      """
+
+  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                 |
+      |                       | faraday (w/ net_http) |
+      |                       | faraday (w/ typhoeus) |
+

data/features/request_matching/path.feature

@@ -0,0 +1,86 @@
+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:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://host1.com:80/about?date=2011-09-01
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "14"
+          body: about response
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :post
+          uri: http://host2.com:80/home?date=2011-09-01
+          body:
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "15"
+          body: home response
+          http_version: "1.1"
+      """
+
+  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                 |
+      |                       | faraday (w/ net_http) |
+      |                       | faraday (w/ typhoeus) |
+

data/features/request_matching/playback_repeats.feature

@@ -0,0 +1,87 @@
+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
+
+  Scenario: Responses do not repeat by default
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://example.com:80/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "10"
+          body: Response 1
+          http_version: "1.1"
+      - !ruby/struct:VCR::HTTPInteraction 
+        request: !ruby/struct:VCR::Request 
+          method: :get
+          uri: http://example.com:80/foo
+          body: 
+          headers: 
+        response: !ruby/struct:VCR::Response 
+          status: !ruby/struct:VCR::ResponseStatus 
+            code: 200
+            message: OK
+          headers: 
+            content-length: 
+            - "10"
+          body: Response 2
+          http_version: "1.1"
+      """
+    And a file named "playback_repeats.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :fakeweb
+        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 "Real HTTP connections are disabled"
+     And the output should contain:
+      """
+      == With :allow_playback_repeats ==
+      Response 1
+      Response 2
+      Response 2
+
+      == Without :allow_playback_repeats ==
+      Response 1
+      Response 2
+      """