vcr 3.0.3 → 6.2.0

data/features/configuration/hook_into.feature

@@ -1,172 +0,0 @@
-Feature: hook_into
-
-  The `hook_into` configuration option determines how VCR hooks into the
-  HTTP requests to record and replay them.  There are currently 4 valid
-  options which support many different HTTP libraries:
-
-    - :webmock can be used to hook into requests from:
-      - Net::HTTP
-      - HTTPClient
-      - Patron
-      - Curb (Curl::Easy, but not Curl::Multi)
-      - EM HTTP Request
-      - Typhoeus (Typhoeus::Hydra, but not Typhoeus::Easy or Typhoeus::Multi)
-      - Excon
-    - :typhoeus can be used to hook into itself (as long as you use Typhoeus::Hydra,
-      but not Typhoeus::Easy or Typhoeus::Multi).
-    - :excon can be used to hook into itself.
-    - :faraday can be used to hook into itself.
-    - :fakeweb (deprecated) can be used to hook into Net::HTTP requests.
-
-  There are some addiitonal trade offs to consider when deciding which
-  option to use:
-
-    - WebMock uses extensive monkey patching to hook into supported HTTP
-      libraries.  No monkey patching is used for Typhoeus, Excon or Faraday.
-    - Typhoeus, Excon, Faraday can be used together, and with either FakeWeb or WebMock.
-    - FakeWeb and WebMock cannot both be used at the same time.
-
-  Regardless of which library you use, VCR takes care of all of the configuration
-  for you.  You should not need to interact directly with FakeWeb, WebMock or the
-  stubbing facilities of Typhoeus, Excon or Faraday.  If/when you decide to change stubbing
-  libraries (i.e. if you initially use FakeWeb because it's faster but later need the
-  additional features of WebMock) you can change the `hook_into` configuration
-  option and it'll work with no other changes required.
-
-  Scenario Outline: Record and replay a request using each supported hook_into/http library combination
-    Given a file named "hook_into_http_lib_combo.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-      VCR.configure { |c| c.ignore_localhost = true }
-
-      $server = start_sinatra_app do
-        get('/') { ARGV[0] }
-      end
-
-      puts "The response for request 1 was: #{response_body_for(:get, "http://localhost:#{$server.port}/")}"
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'vcr_cassettes'
-        c.ignore_localhost = false
-        c.default_cassette_options = { :serialize_with => :syck }
-      end
-
-      VCR.use_cassette('example') do
-        puts "The response for request 2 was: #{response_body_for(:get, "http://localhost:#{$server.port}/")}"
-      end
-      """
-    When I run `ruby hook_into_http_lib_combo.rb 'Hello World'`
-    Then the output should contain each of the following:
-      | The response for request 1 was: Hello World |
-      | The response for request 2 was: Hello World |
-     And the file "vcr_cassettes/example.yml" should contain "Hello World"
-
-    When I run `ruby hook_into_http_lib_combo.rb 'Goodbye World'`
-    Then the output should contain each of the following:
-      | The response for request 1 was: Goodbye World |
-      | The response for request 2 was: Hello World   |
-     And the file "vcr_cassettes/example.yml" should contain "Hello World"
-
-   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 :webmock  | excon                 |
-      | 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) |
-
-  @exclude-jruby @exclude-rbx
-  Scenario Outline: Use Typhoeus, Excon and Faraday in combination with FakeWeb or WebMock
-    Given a file named "hook_into_multiple.rb" with:
-      """ruby
-      require 'typhoeus'
-      require 'excon'
-      require 'faraday'
-      require 'vcr'
-      <extra_require>
-
-      VCR.configure { |c| c.ignore_localhost = true }
-
-      $server = start_sinatra_app do
-        get('/:path') { "#{ARGV[0]} #{params[:path]}" }
-      end
-
-      def net_http_response
-        Net::HTTP.get_response('localhost', '/net_http', $server.port).body
-      end
-
-      def typhoeus_response
-        Typhoeus::Request.get("http://localhost:#{$server.port}/typhoeus").body
-      end
-
-      def excon_response
-        Excon.get("http://localhost:#{$server.port}/excon").body
-      end
-
-      def faraday_response
-        Faraday::Connection.new(:url => "http://localhost:#{$server.port}") do |builder|
-          builder.adapter :<faraday_adapter>
-        end.get('/faraday').body
-      end
-
-      puts "Net::HTTP 1: #{net_http_response}"
-      puts "Typhoeus 1: #{typhoeus_response}"
-      puts "Excon 1: #{excon_response}"
-      puts "Faraday 1: #{faraday_response}"
-
-      VCR.configure do |c|
-        c.hook_into <hook_into>, :typhoeus, :excon, :faraday
-        c.cassette_library_dir = 'vcr_cassettes'
-        c.ignore_localhost = false
-      end
-
-      VCR.use_cassette('example') do
-        puts "Net::HTTP 2: #{net_http_response}"
-        puts "Typhoeus 2: #{typhoeus_response}"
-        puts "Excon 2: #{excon_response}"
-        puts "Faraday 2: #{faraday_response}"
-      end
-      """
-    When I run `ruby hook_into_multiple.rb 'Hello'`
-    Then the output should contain each of the following:
-      | Net::HTTP 1: Hello net_http |
-      | Typhoeus 1: Hello typhoeus  |
-      | Excon 1: Hello excon        |
-      | Faraday 1: Hello faraday    |
-      | Net::HTTP 2: Hello net_http |
-      | Typhoeus 2: Hello typhoeus  |
-      | Excon 2: Hello excon        |
-      | Faraday 2: Hello faraday    |
-    And the cassette "vcr_cassettes/example.yml" should have the following response bodies:
-      | Hello net_http |
-      | Hello typhoeus |
-      | Hello excon    |
-      | Hello faraday  |
-
-    When I run `ruby hook_into_multiple.rb 'Goodbye'`
-    Then the output should contain each of the following:
-      | Net::HTTP 1: Goodbye net_http |
-      | Typhoeus 1: Goodbye typhoeus  |
-      | Excon 1: Goodbye excon        |
-      | Faraday 1: Goodbye faraday    |
-      | Net::HTTP 2: Hello net_http   |
-      | Typhoeus 2: Hello typhoeus    |
-      | Excon 2: Hello excon          |
-      | Faraday 2: Hello faraday      |
-
-    Examples:
-      | hook_into | faraday_adapter | extra_require                       |
-      | :fakeweb  | net_http        |                                     |
-      | :webmock  | net_http        |                                     |
-      | :fakeweb  | typhoeus        | require 'typhoeus/adapters/faraday' |
-      | :webmock  | typhoeus        | require 'typhoeus/adapters/faraday' |

data/features/configuration/ignore_request.feature

@@ -1,192 +0,0 @@
-Feature: Ignore Request
-
-  By default, VCR hooks into every request, either allowing it and recording
-  it, or playing back a recorded response, or raising an error to force you
-  to deal with the new request.  In some situations, you may prefer to have
-  VCR ignore some requests.
-
-  VCR provides 3 configuration options to accomplish this:
-
-    * `ignore_request { |req| ... }` will ignore any request for which the
-      given block returns true.
-    * `ignore_hosts 'foo.com', 'bar.com'` allows you to specify particular
-      hosts to ignore.
-    * `ignore_localhost = true` is equivalent to `ignore_hosts 'localhost',
-      '127.0.0.1', '0.0.0.0'`. It is particularly useful for when you use
-      VCR with a javascript-enabled capybara driver, since capybara boots
-      your rack app and makes localhost requests to it to check that it has
-      booted.
-
-  Ignored requests are not recorded and are always allowed, regardless of
-  the record mode, and even outside of a `VCR.use_cassette` block.
-
-  Background:
-    Given a file named "sinatra_app.rb" with:
-      """ruby
-      response_count = 0
-      $server = start_sinatra_app do
-        get('/') { "Port 7777 Response #{response_count += 1}" }
-      end
-      """
-
-  @exclude-jruby
-  Scenario Outline: ignore requests to a specific port
-    Given a file named "ignore_request.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      response_count = 0
-      $server_8888 = start_sinatra_app do
-        get('/') { "Port 8888 Response #{response_count += 1}" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_request do |request|
-          URI(request.uri).port == $server.port
-        end
-
-        c.default_cassette_options = { :serialize_with => :syck }
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server_8888.port}/")
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      puts response_body_for(:get, "http://localhost:#{$server_8888.port}/")
-      """
-    When I run `ruby ignore_request.rb`
-    Then it should fail with an error like:
-      """
-      An HTTP request has been made that VCR does not know how to handle:
-      """
-     And the output should contain:
-      """
-      Port 8888 Response 1
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/example.yml" should contain "Port 8888"
-    And the file "cassettes/example.yml" should not contain "Port 7777"
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario Outline: ignored host requests are not recorded and are always allowed
-    Given a file named "ignore_hosts.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_hosts '127.0.0.1', 'localhost'
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby ignore_hosts.rb`
-    Then it should pass with:
-      """
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/example.yml" should not exist
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  @exclude-jruby
-  Scenario Outline: localhost requests are not treated differently by default
-    Given a file named "localhost_not_ignored.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = { :serialize_with => :syck }
-        <configuration>
-      end
-
-      VCR.use_cassette('localhost') do
-        response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby localhost_not_ignored.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-     And the file "cassettes/localhost.yml" should contain "Port 7777 Response 1"
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-
-  Scenario Outline: localhost requests are allowed and not recorded when ignore_localhost = true
-    Given a file named "ignore_localhost_true.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-      require 'sinatra_app.rb'
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.ignore_localhost = true
-        c.cassette_library_dir = 'cassettes'
-        <configuration>
-      end
-
-      VCR.use_cassette('localhost') do
-        puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      end
-
-      puts response_body_for(:get, "http://localhost:#{$server.port}/")
-      """
-    When I run `ruby ignore_localhost_true.rb`
-    Then it should pass with:
-      """
-      Port 7777 Response 1
-      Port 7777 Response 2
-      """
-    And the file "cassettes/localhost.yml" should not exist
-
-    Examples:
-      | configuration         | http_lib              |
-      | c.hook_into :fakeweb  | net/http              |
-      | c.hook_into :webmock  | net/http              |
-      | c.hook_into :typhoeus | typhoeus              |
-      | c.hook_into :excon    | excon                 |
-      | c.hook_into :faraday  | faraday (w/ net_http) |
-

data/features/configuration/preserve_exact_body_bytes.feature

@@ -1,108 +0,0 @@
-@exclude-18
-Feature: Preserve Exact Body Bytes
-
-  Some HTTP servers are not well-behaved and respond with invalid data: the response body may
-  not be encoded according to the encoding specified in the HTTP headers, or there may be bytes
-  that are invalid for the given encoding. The YAML and JSON serializers are not generally
-  designed to handle these cases gracefully, and you may get errors when the cassette is serialized
-  or deserialized. Also, the encoding may not be preserved when round-tripped through the
-  serializer.
-
-  VCR provides a configuration option to deal with cases like these. The `preserve_exact_body_bytes`
-  method accepts a block that VCR will use to determine if the body of the given request or response object
-  should be base64 encoded in order to preserve the bytes exactly as-is. VCR does not do this by
-  default, since base64-encoding the string removes the human readibility of the cassette.
-
-  Alternately, if you want to force an entire cassette to preserve the exact body bytes,
-  you can pass the `:preserve_exact_body_bytes => true` cassette option when inserting your
-  cassette.
-
-  Scenario: Preserve exact bytes for response body with invalid encoding
-    Given a file named "preserve.rb" with:
-      """ruby
-      # encoding: utf-8
-      string = "abc \xFA"
-      puts "Valid encoding: #{string.valid_encoding?}"
-
-      $server = start_sinatra_app do
-        get('/') { string }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-        c.preserve_exact_body_bytes do |http_message|
-          http_message.body.encoding.name == 'ASCII-8BIT' ||
-          !http_message.body.valid_encoding?
-        end
-      end
-
-      def make_request(label)
-        puts
-        puts label
-        VCR.use_cassette('example', :serialize_with => :json) do
-          body = Net::HTTP.get_response('localhost', '/', $server.port).body
-          puts "Body: #{body.inspect}"
-        end
-      end
-
-      make_request("Recording:")
-      make_request("Playback:")
-      """
-    When I run `ruby preserve.rb`
-    Then the output should contain exactly:
-      """
-      Valid encoding: false
-
-      Recording:
-      Body: "abc \xFA"
-
-      Playback:
-      Body: "abc \xFA"
-
-      """
-    And the file "cassettes/example.json" should contain:
-      """
-      "body":{"encoding":"ASCII-8BIT","base64_string":"YWJjIPo=\n"}
-      """
-
-  Scenario: Preserve exact bytes for cassette with `:preserve_exact_body_bytes` option
-    Given a file named "preserve.rb" with:
-      """ruby
-      $server = start_sinatra_app do
-        get('/') { "Hello World" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-        c.default_cassette_options = { :serialize_with => :json }
-
-        c.before_record do |i|
-          # otherwise Ruby 2.0 will default to UTF-8:
-          i.response.body.force_encoding('US-ASCII')
-        end
-      end
-
-      VCR.use_cassette('preserve_bytes', :preserve_exact_body_bytes => true) do
-        Net::HTTP.get_response('localhost', '/', $server.port)
-      end
-
-      VCR.use_cassette('dont_preserve_bytes') do
-        Net::HTTP.get_response('localhost', '/', $server.port)
-      end
-      """
-    When I run `ruby preserve.rb`
-    Then the file "cassettes/preserve_bytes.json" should contain:
-      """
-      "body":{"encoding":"US-ASCII","base64_string":"SGVsbG8gV29ybGQ=\n"}
-      """
-     And the file "cassettes/dont_preserve_bytes.json" should contain:
-      """
-      "body":{"encoding":"US-ASCII","string":"Hello World"}
-      """
-

data/features/configuration/query_parser.feature

@@ -1,84 +0,0 @@
-Feature: query_parser
-
-  By default, VCR will parse query strings using `CGI.parse` from the Ruby
-  standard library. This may not be the most optimal or performant library
-  available.  You can set the `query_parser` configuration option to use a
-  different parser (such as `Rack::Utils.method(:parse_query)`) to decode,
-  normalize, and/or provide a comparison object for query strings.
-
-  The configured query parser needs to expose a `.call` method that returns an
-  object which is comparable. This instance needs to implement the following
-  API:
-
-    * `#==`     => boolean
-
-  Background:
-    Given a file named "cassettes/example.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: get
-          uri: http://url.example.com/?bravo=2&alpha=1
-          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, 25 Sep 2012 04:58:44 GMT
-      recorded_with: VCR 2.2.5
-      """
-
-  Scenario: the VCR query parser gets its value from `query_parser`
-    Given a file named "query_parser.rb" with:
-      """ruby
-      require 'vcr'
-      require 'rack'
-
-      VCR.configure do |c|
-        c.query_parser = lambda { |query| raise query.inspect }
-        c.default_cassette_options = {:match_requests_on => [:query]}
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      uri = URI.parse('http://other-url.example.com/?bravo=2&alpha=1')
-      VCR.use_cassette('example') do
-        puts Net::HTTP.get_response(uri).body
-      end
-      """
-     When I run `ruby query_parser.rb`
-     Then it should fail with an error like:
-     """
-     "alpha=1&bravo=2"
-     """
-
-
-  Scenario: the `query_parser` defaults to the standard library's `CGI.parse`
-    Given a file named "query_parser_default.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.default_cassette_options = {:match_requests_on => [:query]}
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      uri = URI.parse('http://other-url.example.com/?bravo=2&alpha=1')
-      VCR.use_cassette('example') do
-        puts Net::HTTP.get_response(uri).body
-      end
-      """
-     When I run `ruby query_parser_default.rb`
-     Then it should pass with "Hello"

data/features/configuration/uri_parser.feature

@@ -1,93 +0,0 @@
-Feature: uri_parser
-
-  By default, VCR will parse URIs using `URI` from the Ruby standard
-  library. There are some URIs seen out in the wild that `URI` cannot
-  parse properly. You can set the `uri_parser` configuration option
-  to use a different parser (such as `Addressable::URI`) to work with
-  these URIs.
-
-  The configured URI parser needs to expose a `.parse` class method
-  that returns an instance of the uri. This uri instance needs to
-  implement the following API:
-
-    * `#scheme` => a string
-    * `#host`   => a string
-    * `#port`   => a fixnum
-    * `#path`   => a string
-    * `#query`  => a string
-    * `#to_s`   => a string
-    * `#port=`
-    * `#query=`
-    * `#==`     => boolean
-
-  Background:
-    Given a file named "cassettes/example.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: get
-          uri: http://example.com/hello
-          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, 25 Sep 2012 04:58:44 GMT
-      recorded_with: VCR 2.2.5
-      """
-
-  Scenario: the VCR uri parser gets its value from `uri_parser`
-    Given a file named "uri_parser.rb" with:
-      """ruby
-      require 'vcr'
-      require 'uri'
-
-      module MyURI
-        def self.parse(url)
-          uri = URI.parse(url)
-          uri.host = 'example.com'
-          uri.path = '/hello'
-          uri
-        end
-      end
-
-      VCR.configure do |c|
-        c.uri_parser = MyURI
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        puts Net::HTTP.get_response('evil.org', '/projects').body
-      end
-      """
-     When I run `ruby uri_parser.rb`
-     Then it should pass with "Hello"
-
-  Scenario: the `uri_parser` defaults to the standard library's `URI`
-    Given a file named "uri_parser_default.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        puts Net::HTTP.get_response('example.com', '/hello').body
-      end
-      """
-     When I run `ruby uri_parser_default.rb`
-     Then it should pass with "Hello"