vcr 3.0.3 → 6.1.0

data/features/cassettes/exclusive.feature

@@ -1,126 +0,0 @@
-Feature: exclusive cassette
-
-  VCR allows cassettes to be nested. This is particularly useful in
-  a context like cucumber, where you may be using a cassette for an
-  entire scenario, and also using a cassette within a particular step
-  definition.
-
-  By default, both the inner and outer cassettes are active. On each
-  request, VCR will look for a matching HTTP interaction in the inner
-  cassette, and it will use the outer cassette as a fall back if none
-  can be found.
-
-  If you do not want the HTTP interactions of the outer cassette considered,
-  you can pass the `:exclusive` option, so that the inner cassette is
-  used exclusively.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/outer.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/outer
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: Old outer response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a previously recorded cassette file "cassettes/inner.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://localhost/inner
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "18"
-          body: 
-            encoding: UTF-8
-            string: Old inner 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 "setup.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      $server = start_sinatra_app do
-        get('/:path') { "New #{params[:path]} response" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = {
-          :record => :new_episodes,
-          :match_requests_on => [:method, :host, :path]
-        }
-      end
-      """
-
-  Scenario: Cassettes are not exclusive by default
-    Given a file named "not_exclusive.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('outer') do
-        VCR.use_cassette('inner') do
-          puts response_body_for(:get, "http://localhost:#{$server.port}/outer")
-          puts response_body_for(:get, "http://localhost:#{$server.port}/inner")
-        end
-      end
-      """
-    When I run `ruby not_exclusive.rb`
-    Then it should pass with:
-      """
-      Old outer response
-      Old inner response
-      """
-
-  Scenario: Use an exclusive cassette
-    Given a file named "exclusive.rb" with:
-      """ruby
-      require 'setup'
-
-      VCR.use_cassette('outer') do
-        VCR.use_cassette('inner', :exclusive => true) do
-          puts response_body_for(:get, "http://localhost:#{$server.port}/outer")
-          puts response_body_for(:get, "http://localhost:#{$server.port}/inner")
-        end
-      end
-      """
-    When I run `ruby exclusive.rb`
-    Then it should pass with:
-      """
-      New outer response
-      Old inner response
-      """
-    And the file "cassettes/inner.yml" should contain "New outer response"
-

data/features/cassettes/format.feature

@@ -1,411 +0,0 @@
-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.
-    - `:compressed`--Wraps the default YAML serializer with Zlib, writing
-      compressed cassettes to disk.
-
-  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 as compressed YAML
-    Given a file named "cassette_compressed.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 => :compressed) 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_compressed.rb 'Hello'`
-    Then the file "cassettes/example.gz" should contain compressed 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
-        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
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    When I run `ruby cassette_compressed.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

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

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