mustwin-vcr 2.9.3

data/features/cassettes/format.feature

@@ -0,0 +1,323 @@
+Feature: Cassette format
+
+  VCR Cassettes are files that contain all of the information
+  about the requests and corresponding responses in a
+  human-readable/editable format.  A cassette contains an array
+  of HTTP interactions, each of which has the following:
+
+    - request
+      - method
+      - uri
+      - body
+        - encoding
+        - string
+      - headers
+    - response
+      - status
+        - code
+        - message
+      - headers
+      - body
+        - encoding
+        - string
+      - http version
+
+  By default, VCR uses YAML to serialize this data.  You can configure
+  VCR to use a different serializer, either on a cassette-by-cassette
+  basis, or as a default for all cassettes if you use the `default_cassette_options`.
+
+  VCR supports the following serializers out of the box:
+
+    - `:yaml`--Uses ruby's standard library YAML. This may use psych or syck,
+      depending on your ruby installation.
+    - `:syck`--Uses syck (the ruby 1.8 YAML engine). This is useful when using
+      VCR on a project that must run in environments where psych is not available
+      (such as on ruby 1.8), to ensure that syck is always used.
+    - `:psych`--Uses psych (the new ruby 1.9 YAML engine). This is useful when
+      you want to ensure that psych is always used.
+    - `:json`--Uses [multi_json](https://github.com/intridea/multi_json)
+      to serialize the cassette data as JSON.
+
+  You can also register a custom serializer using:
+
+       VCR.configure do |config|
+         config.cassette_serializers[:my_custom_serializer] = my_serializer
+       end
+
+  Your serializer must implement the following methods:
+
+    - `file_extension`
+    - `serialize(hash)`
+    - `deserialize(string)`
+
+  Scenario Outline: Request/Response data is saved to disk as YAML by default
+    Given a file named "cassette_yaml.rb" with:
+      """ruby
+      include_http_adapter_for("<http_lib>")
+
+      if ARGV.any?
+        $server = start_sinatra_app do
+          get('/:path') { ARGV[0] + ' ' + params[:path] }
+        end
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        <configuration>
+        c.cassette_library_dir = 'cassettes'
+        c.before_record do |i|
+          i.request.uri.sub!(/:\d+/, ':7777')
+        end
+      end
+
+      VCR.use_cassette('example') do
+        make_http_request(:get, "http://localhost:#{$server.port}/foo", nil, 'Accept-Encoding' => 'identity')
+        make_http_request(:get, "http://localhost:#{$server.port}/bar", nil, 'Accept-Encoding' => 'identity')
+      end
+      """
+    When I successfully run `ruby cassette_yaml.rb 'Hello'`
+    Then the file "cassettes/example.yml" should contain YAML like:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: get
+          uri: http://localhost:7777/foo
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: 
+            Accept-Encoding: 
+            - identity
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Type: 
+            - text/html;charset=utf-8
+            Content-Length: 
+            - "9"
+          body: 
+            encoding: UTF-8
+            string: Hello foo
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      - request: 
+          method: get
+          uri: http://localhost:7777/bar
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: 
+            Accept-Encoding: 
+            - identity
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Type: 
+            - text/html;charset=utf-8
+            Content-Length: 
+            - "9"
+          body: 
+            encoding: UTF-8
+            string: Hello bar
+          http_version: "1.1"
+        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
+      recorded_with: VCR 2.0.0
+      """
+
+    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  | patron                |
+      | c.hook_into :webmock  | curb                  |
+      | 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) |
+
+  Scenario: Request/Response data can be saved as JSON
+    Given a file named "cassette_json.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      $server = start_sinatra_app do
+        get('/:path') { ARGV[0] + ' ' + params[:path] }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+        c.before_record do |i|
+          i.request.uri.sub!(/:\d+/, ':7777')
+        end
+        c.default_cassette_options = {
+          :match_requests_on => [:method, :host, :path]
+        }
+      end
+
+      VCR.use_cassette('example', :serialize_with => :json) do
+        puts response_body_for(:get, "http://localhost:#{$server.port}/foo", nil, 'Accept-Encoding' => 'identity')
+        puts response_body_for(:get, "http://localhost:#{$server.port}/bar", nil, 'Accept-Encoding' => 'identity')
+      end
+      """
+    When I run `ruby cassette_json.rb 'Hello'`
+    Then the file "cassettes/example.json" should contain JSON like:
+      """json
+      {
+        "http_interactions": [
+          {
+            "response": {
+              "body": {
+                "encoding": "UTF-8",
+                "string": "Hello foo"
+              },
+              "http_version": null,
+              "status": { "code": 200, "message": "OK" },
+              "headers": {
+                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
+                "Content-Type": [ "text/html;charset=utf-8" ],
+                "Content-Length": [ "9" ],
+                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
+                "Connection": [ "Keep-Alive" ]
+              }
+            },
+            "request": {
+              "uri": "http://localhost:7777/foo",
+              "body": {
+                "encoding": "UTF-8",
+                "string": ""
+              },
+              "method": "get",
+              "headers": {
+                "Accept-Encoding": [ "identity" ]
+              }
+            },
+            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
+          },
+          {
+            "response": {
+              "body": {
+                "encoding": "UTF-8",
+                "string": "Hello bar"
+              },
+              "http_version": null,
+              "status": { "code": 200, "message": "OK" },
+              "headers": {
+                "Date": [ "Thu, 27 Oct 2011 06:16:31 GMT" ],
+                "Content-Type": [ "text/html;charset=utf-8" ],
+                "Content-Length": [ "9" ],
+                "Server": [ "WEBrick/1.3.1 (Ruby/1.8.7/2011-06-30)" ],
+                "Connection": [ "Keep-Alive" ]
+              }
+            },
+            "request": {
+              "uri": "http://localhost:7777/bar",
+              "body": {
+                "encoding": "UTF-8",
+                "string": ""
+              },
+              "method": "get",
+              "headers": {
+                "Accept-Encoding": [ "identity" ]
+              }
+            },
+            "recorded_at": "Tue, 01 Nov 2011 04:58:44 GMT"
+          }
+        ],
+        "recorded_with": "VCR 2.0.0"
+      }
+      """
+    When I run `ruby cassette_json.rb`
+    Then it should pass with:
+      """
+      Hello foo
+      Hello bar
+      """
+
+  Scenario: Request/Response data can be saved using a custom serializer
+    Given a file named "cassette_ruby.rb" with:
+      """ruby
+      include_http_adapter_for("net/http")
+
+      $server = start_sinatra_app do
+        get('/:path') { ARGV[0] + ' ' + params[:path] }
+      end
+
+      require 'vcr'
+
+      # purely for demonstration purposes; obviously, don't actually
+      # use ruby #inspect / #eval for your serialization...
+      ruby_serializer = Object.new
+      class << ruby_serializer
+        def file_extension; "ruby"; end
+        def serialize(hash); hash.inspect; end
+        def deserialize(string); eval(string); end
+      end
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+        c.cassette_library_dir = 'cassettes'
+        c.cassette_serializers[:ruby] = ruby_serializer
+        c.before_record do |i|
+          i.request.uri.sub!(/:\d+/, ':7777')
+        end
+        c.default_cassette_options = {
+          :match_requests_on => [:method, :host, :path]
+        }
+      end
+
+      VCR.use_cassette('example', :serialize_with => :ruby) do
+        puts response_body_for(:get, "http://localhost:#{$server.port}/foo", nil, 'Accept-Encoding' => 'identity')
+        puts response_body_for(:get, "http://localhost:#{$server.port}/bar", nil, 'Accept-Encoding' => 'identity')
+      end
+      """
+    When I run `ruby cassette_ruby.rb 'Hello'`
+    Then the file "cassettes/example.ruby" should contain ruby like:
+      """
+      {"http_interactions"=>
+        [{"request"=>
+           {"method"=>"get",
+            "uri"=>"http://localhost:7777/foo",
+            "body"=>{"encoding"=>"UTF-8", "string"=>""},
+            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
+          "response"=>
+           {"status"=>{"code"=>200, "message"=>"OK "},
+            "headers"=>
+             {"Content-Type"=>["text/html;charset=utf-8"],
+              "Content-Length"=>["9"],
+              "Connection"=>["Keep-Alive"]},
+            "body"=>{"encoding"=>"UTF-8", "string"=>"Hello foo"},
+            "http_version"=>nil},
+          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"},
+         {"request"=>
+           {"method"=>"get",
+            "uri"=>"http://localhost:7777/bar",
+            "body"=>{"encoding"=>"UTF-8", "string"=>""},
+            "headers"=>{"Accept"=>["*/*"], "Accept-Encoding"=>["identity"], "User-Agent"=>["Ruby"]}},
+          "response"=>
+           {"status"=>{"code"=>200, "message"=>"OK "},
+            "headers"=>
+             {"Content-Type"=>["text/html;charset=utf-8"],
+              "Content-Length"=>["9"],
+              "Connection"=>["Keep-Alive"]},
+            "body"=>{"encoding"=>"UTF-8", "string"=>"Hello bar"},
+            "http_version"=>nil},
+          "recorded_at"=>"Tue, 01 Nov 2011 04:58:44 GMT"}],
+       "recorded_with"=>"VCR 2.0.0"}
+      """
+    When I run `ruby cassette_ruby.rb`
+    Then it should pass with:
+      """
+      Hello foo
+      Hello bar
+      """

data/features/cassettes/freezing_time.feature

@@ -0,0 +1,68 @@
+Feature: Freezing Time
+
+  When dealing with an HTTP API that includes time-based compontents
+  in the request (e.g. for signed S3 requests), it can be useful
+  on playback to freeze time to what it originally was when the
+  cassette was recorded so that the request is always the same
+  each time your test is run.
+
+  While VCR doesn't directly support time freezing, it does
+  expose `VCR::Cassette#originally_recorded_at`, which you can
+  easily use with a library like
+  [timecop](https://github.com/travisjeffery/timecop)
+  to freeze time.
+
+  Note: `VCR::Cassette#originally_recorded_at` will return `nil`
+  when the cassette is recording for the first time, so you'll
+  probably want to use an expression like
+  `cassette.originally_recorded_at || Time.now` so that it
+  will work when recording or when playing back.
+
+  Scenario: Previously recorded responses are replayed
+    Given a previously recorded cassette file "cassettes/example.yml" with:
+      """
+      --- 
+      http_interactions: 
+      - request: 
+          method: get
+          uri: http://example.com/events/since/2013-09-23T17:00:30Z
+          body: 
+            encoding: UTF-8
+            string: ""
+          headers: {}
+        response: 
+          status: 
+            code: 200
+            message: OK
+          headers: 
+            Content-Length: 
+            - "20"
+          body: 
+            encoding: UTF-8
+            string: Some Event
+          http_version: "1.1"
+        recorded_at: Mon, 23 Sep 2013 17:00:30 GMT
+      recorded_with: VCR 2.0.0
+      """
+    Given a file named "freeze_time.rb" with:
+      """ruby
+      require 'time'
+      require 'timecop'
+      require 'vcr'
+
+      VCR.configure do |vcr|
+        vcr.cassette_library_dir = 'cassettes'
+        vcr.hook_into :webmock
+      end
+
+      VCR.use_cassette('example') do |cassette|
+        Timecop.freeze(cassette.originally_recorded_at || Time.now) do
+          path = "/events/since/#{Time.now.getutc.iso8601}"
+          response = Net::HTTP.get_response('example.com', path)
+          puts "Response: #{response.body}"
+        end
+      end
+      """
+    When I run `ruby freeze_time.rb`
+    Then it should pass with "Response: Some Event"
+

data/features/cassettes/naming.feature

@@ -0,0 +1,28 @@
+Feature: Naming
+
+  When inserting or using a cassette, the first argument is the cassette name.
+  You can use any string for the name.  If you use the default `:file_system`
+  storage backend, VCR will sanitize the string before using it as a file name,
+  so that it is a file-system friendly file name.
+
+  Scenario: Name sanitizing
+    Given a file named "name_sanitizing.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { "Hello" }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.hook_into :webmock
+      end
+
+      VCR.use_cassette('Fee, Fi Fo Fum') do
+        Net::HTTP.get_response('localhost', '/', $server.port)
+      end
+      """
+     And the directory "cassettes" does not exist
+    When I run `ruby name_sanitizing.rb`
+    Then the file "cassettes/Fee_Fi_Fo_Fum.yml" should contain "Hello"

data/features/cassettes/no_cassette.feature

@@ -0,0 +1,152 @@
+Feature: Error for HTTP request made when no cassette is in use
+
+  VCR is designed to help you remove all HTTP dependencies from your
+  test suite.  To assist with this, VCR will cause an exception to be
+  raised when an HTTP request is made while there is no cassette in
+  use.  The error is helpful to pinpoint where HTTP requests are
+  made so you can use a VCR cassette at that point in your code.
+
+  If you want insight about how VCR attempted to handle the request,
+  you can use the [debug\_logger](../configuration/debug-logging)
+  configuration option to log more details.
+
+  If you want to allow an HTTP request to proceed as normal, you can
+  set the [allow\_http\_connections\_when\_no\_cassette](../configuration/allow-http-connections-when-no-cassette)
+  configuration option or you can temporarily turn VCR off:
+
+    - `VCR.turn_off!` => turn VCR off so HTTP requests are allowed.
+      Cassette insertions will trigger an error.
+    - `VCR.turn_off!(:ignore_cassettes => true)` => turn
+      VCR off and ignore cassette insertions (so that no error is raised).
+    - `VCR.turn_on!` => turn VCR back on
+    - `VCR.turned_off { ... }` => turn VCR off for the duration of the
+      provided block.
+
+  @exclude-jruby
+  Scenario Outline: Error for request when no cassette is in use
+    Given a file named "no_cassette_error.rb" with:
+      """ruby
+      include_http_adapter_for("<http_lib>")
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        <configuration>
+        c.cassette_library_dir = 'cassettes'
+      end
+
+      response_body_for(:get, 'http://example.com/')
+      """
+    When I run `ruby no_cassette_error.rb`
+    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
+
+    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) |
+
+  Scenario: Temporarily turn VCR off to allow HTTP requests to procede as normal
+    Given a file named "turn_off_vcr.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { 'Hello' }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+      end
+      WebMock.allow_net_connect!
+
+      def make_request(context)
+        puts context
+        puts Net::HTTP.get_response('localhost', '/', $server.port).body
+      rescue => e
+        puts "Error: #{e.class}"
+      end
+
+      VCR.turned_off do
+        make_request "In VCR.turned_off block"
+      end
+
+      make_request "Outside of VCR.turned_off block"
+
+      VCR.turn_off!
+      make_request "After calling VCR.turn_off!"
+
+      VCR.turn_on!
+      make_request "After calling VCR.turn_on!"
+      """
+    When I run `ruby turn_off_vcr.rb`
+    Then the output should contain:
+      """
+      In VCR.turned_off block
+      Hello
+      """
+    And the output should contain:
+      """
+      Outside of VCR.turned_off block
+      Error: VCR::Errors::UnhandledHTTPRequestError
+      """
+    And the output should contain:
+      """
+      After calling VCR.turn_off!
+      Hello
+      """
+    And the output should contain:
+      """
+      After calling VCR.turn_on!
+      Error: VCR::Errors::UnhandledHTTPRequestError
+      """
+
+  Scenario: Turning VCR off prevents cassettes from being inserted
+    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
+      """ruby
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.hook_into :webmock
+      end
+      WebMock.allow_net_connect!
+
+      VCR.turn_off!
+      VCR.insert_cassette('example')
+      """
+    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
+    Then it should fail with "VCR is turned off.  You must turn it on before you can insert a cassette."
+
+  Scenario: Turning VCR off with `:ignore_cassettes => true` ignores cassettes
+    Given a file named "turn_off_vcr_and_insert_cassette.rb" with:
+      """ruby
+      $server = start_sinatra_app do
+        get('/') { 'Hello' }
+      end
+
+      require 'vcr'
+
+      VCR.configure do |c|
+        c.cassette_library_dir = 'cassettes'
+        c.hook_into :webmock
+      end
+      WebMock.allow_net_connect!
+
+      VCR.turn_off!(:ignore_cassettes => true)
+
+      VCR.use_cassette('example') do
+        response = Net::HTTP.get_response('localhost', '/', $server.port).body
+        puts "Response: #{response}"
+      end
+      """
+    When I run `ruby turn_off_vcr_and_insert_cassette.rb`
+    Then it should pass with "Response: Hello"
+     And the file "cassettes/example.yml" should not exist
+