mustwin-vcr 2.9.3

data/features/configuration/hook_into.feature

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

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

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