mustwin-vcr 2.9.3

data/features/middleware/faraday.feature

@@ -0,0 +1,56 @@
+Feature: Faraday middleware
+
+  VCR provides middleware that can be used with Faraday.  You can use this as
+  an alternative to Faraday's built-in test adapter.
+
+  VCR will automatically insert this middleware in the Faraday stack
+  when you configure `hook_into :faraday`. However, if you want to control
+  where the middleware goes in the faraday stack, you can use it yourself.
+  The middleware should come before the Faraday HTTP adapter.
+
+  Note that when you use the middleware directly, you don't need to configure
+  `hook_into :faraday`.
+
+  Scenario Outline: Use Faraday middleware
+    Given a file named "faraday_example.rb" with:
+      """ruby
+      request_count = 0
+      $server = start_sinatra_app do
+        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
+      end
+
+      require 'faraday'
+      require 'vcr'
+      <extra_require>
+
+      VCR.configure do |c|
+        c.default_cassette_options = { :serialize_with => :syck }
+        c.cassette_library_dir = 'cassettes'
+      end
+
+      conn = Faraday::Connection.new(:url => "http://localhost:#{$server.port}") do |builder|
+        builder.use VCR::Middleware::Faraday
+        builder.adapter :<adapter>
+      end
+
+      VCR.use_cassette('example') do
+        puts "Response 1: #{conn.get('/foo').body}"
+      end
+
+      VCR.use_cassette('example') do
+        puts "Response 2: #{conn.get('/foo').body}"
+      end
+      """
+    When I run `ruby faraday_example.rb`
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/example.yml" should contain "Hello foo 1"
+
+    Examples:
+      | adapter  | extra_require                       |
+      | net_http |                                     |
+      | typhoeus | require 'typhoeus/adapters/faraday' |
+

data/features/middleware/rack.feature

@@ -0,0 +1,92 @@
+Feature: Rack
+
+  VCR provides a rack middleware that uses a cassette for the duration of
+  a request.  Simply provide `VCR::Middleware::Rack` with a block that sets
+  the cassette name and options.  You can set these based on the rack env
+  if your block accepts two arguments.
+
+  This is useful in a couple different ways:
+
+  - In a rails app, you could use this to log all HTTP API calls made by
+    the rails app (using the `:all` record mode).  Of course, this will only
+    record HTTP API calls made in the request-response cycle--API calls that
+    are offloaded to a background job will not be logged.
+  - This can be used as middleware in a simple rack HTTP proxy, to record
+    and replay the proxied requests.
+
+  Background:
+    Given a file named "remote_server.rb" with:
+      """ruby
+      request_count = 0
+      $server = start_sinatra_app do
+        get('/:path') { "Hello #{params[:path]} #{request_count += 1}" }
+      end
+      """
+    And a file named "client.rb" with:
+      """ruby
+      require 'remote_server'
+      require 'proxy_server'
+      require 'cgi'
+
+      url = URI.parse("http://localhost:#{$proxy.port}?url=#{CGI.escape("http://localhost:#{$server.port}/foo")}")
+
+      puts "Response 1: #{Net::HTTP.get_response(url).body}"
+      puts "Response 2: #{Net::HTTP.get_response(url).body}"
+      """
+    And the directory "cassettes" does not exist
+
+  Scenario: Use VCR rack middleware to record HTTP responses for a simple rack proxy app
+    Given a file named "proxy_server.rb" with:
+      """ruby
+      require 'vcr'
+
+      $proxy = start_sinatra_app do
+        use VCR::Middleware::Rack do |cassette|
+          cassette.name    'proxied'
+          cassette.options :record => :new_episodes
+        end
+
+        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
+      end
+
+      VCR.configure do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.hook_into :webmock
+        c.allow_http_connections_when_no_cassette = true
+      end
+      """
+    When I run `ruby client.rb`
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/proxied.yml" should contain "Hello foo 1"
+
+  Scenario: Set cassette name based on rack request env
+    Given a file named "proxy_server.rb" with:
+      """ruby
+      require 'vcr'
+
+      $proxy = start_sinatra_app do
+        use VCR::Middleware::Rack do |cassette, env|
+          cassette.name    env['SERVER_NAME']
+        end
+
+        get('/') { Net::HTTP.get_response(URI.parse(params[:url])).body }
+      end
+
+      VCR.configure do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.hook_into :webmock
+        c.allow_http_connections_when_no_cassette = true
+      end
+      """
+    When I run `ruby client.rb`
+    Then the output should contain:
+      """
+      Response 1: Hello foo 1
+      Response 2: Hello foo 1
+      """
+    And the file "cassettes/localhost.yml" should contain "Hello foo 1"
+

data/features/record_modes/all.feature

@@ -0,0 +1,82 @@
+Feature: :all
+
+  The `:all` record mode will:
+
+    - Record new interactions.
+    - Never replay previously recorded interactions.
+
+  This can be temporarily used to force VCR to re-record
+  a cassette (i.e. to ensure the responses are not out of date)
+  or can be used when you simply want to log all HTTP requests.
+
+  Background:
+    Given a file named "setup.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/')    { 'Hello' }
+        get('/foo') { 'Goodbye' }
+      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://localhost/
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "20"
+          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
+      """
+
+  Scenario: Re-record previously recorded response
+    Given a file named "re_record.rb" with:
+      """ruby
+      require 'setup'
+
+      VCR.use_cassette('example', :record => :all, :match_requests_on => [:method, :host, :path]) do
+        response = Net::HTTP.get_response('localhost', '/', $server.port)
+        puts "Response: #{response.body}"
+      end
+      """
+    When I run `ruby re_record.rb`
+    Then it should pass with "Response: Hello"
+    And the file "cassettes/example.yml" should contain "Hello"
+    But the file "cassettes/example.yml" should not contain "old response"
+
+  Scenario: Record new request
+    Given a file named "record_new.rb" with:
+      """ruby
+      require 'setup'
+
+      VCR.use_cassette('example', :record => :all) do
+        response = Net::HTTP.get_response('localhost', '/foo', $server.port)
+        puts "Response: #{response.body}"
+      end
+      """
+    When I run `ruby record_new.rb`
+    Then it should pass with "Response: Goodbye"
+    And the file "cassettes/example.yml" should contain each of these:
+      | old response |
+      | Goodbye      |

data/features/record_modes/new_episodes.feature

@@ -0,0 +1,79 @@
+Feature: :new_episodes
+
+  The `:new_episodes` record mode will:
+
+    - Record new interactions.
+    - Replay previously recorded interactions.
+
+  It is similar to the `:once` record mode, but will _always_ record new
+  interactions, even if you have an existing recorded one that is similar
+  (but not identical, based on the `:match_request_on` option).
+
+  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 => :new_episodes) 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"
+
+  Scenario: New requests get recorded
+    Given a file named "record_new_requests.rb" with:
+      """ruby
+      require 'setup'
+
+      VCR.use_cassette('example', :record => :new_episodes) do
+        response = Net::HTTP.get_response('localhost', '/', $server.port)
+        puts "Response: #{response.body}"
+      end
+      """
+    When I run `ruby record_new_requests.rb`
+    Then it should pass with "Response: Hello"
+    And the file "cassettes/example.yml" should contain each of these:
+      | example.com response |
+      | Hello                |

data/features/record_modes/none.feature

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

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