dwolla_swagger 1.0.6 → 1.0.7

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/cassettes/update_content_length_header.feature

@@ -1,112 +0,0 @@
-Feature: Update content_length header
-
-  When the `:update_content_length_header` option is set to a truthy value,
-  VCR will ensure that the `Content-Length` header will have the correct
-  value.  This is useful in several situations:
-
-    - When you manually edit the cassette file and change the resonse body
-      length.  You can use this option so you don't have to manually calculate
-      and update the body length.
-    - When you use ERB, the response body length may vary.  This will ensure
-      it is always correct.
-    - Syck, the default YAML engine for ruby 1.8 (and 1.9, unless you compile
-      it to use Psych), has a bug where it sometimes will remove some
-      whitespace strings when you serialize them.  This may cause the
-      `Content-Length` header to have the wrong value.
-
-  This is especially important when you use a client that checks the
-  `Content-Length` header.  Mechanize, for example, will raise an `EOFError`
-  when the header value does not match the actual body length.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Type: 
-            - text/html;charset=utf-8
-            Content-Length: 
-            - "11"
-          body: 
-            encoding: UTF-8
-            string: Hello <modified>
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "common_stuff.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'cassettes'
-        c.hook_into :webmock
-      end
-
-      def make_request_and_print_results
-        response = Net::HTTP.get_response('example.com', '/')
-        puts "Body length: #{response.body.length}"
-        puts "Header value: #{response['Content-Length']}"
-      end
-      """
-
-  Scenario: Default :update_content_length_header setting
-    Given a file named "default.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example') do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby default.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => false
-    Given a file named "false.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => false) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby false.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 11
-      """
-
-  Scenario: :update_content_length_header => true
-    Given a file named "true.rb" with:
-      """ruby
-      require 'common_stuff'
-
-      VCR.use_cassette('example', :update_content_length_header => true) do
-        make_request_and_print_results
-      end
-      """
-    When I run `ruby true.rb`
-    Then the output should contain:
-      """
-      Body length: 16
-      Header value: 16
-      """
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/configuration/allow_http_connections_when_no_cassette.feature

@@ -1,52 +0,0 @@
-Feature: Allow HTTP connections when no cassette
-
-  Usually, HTTP requests made when no cassette is inserted will [result in an
-  error](../cassettes/error-for-http-request-made-when-no-cassette-is-in-use).
-  You can set the `allow_http_connections_when_no_cassette` configuration option
-  to true to allow requests, if you do not want to use VCR for everything.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.allow_http_connections_when_no_cassette = true
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-    And the directory "vcr/cassettes" does not exist
-
-  Scenario: Allow HTTP connections when no cassette
-    Given a file named "no_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      puts "Response: " + Net::HTTP.get_response('localhost', '/', 7777).body
-      """
-    When I run `ruby no_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-
-  Scenario: Cassettes record and replay as normal
-    Given a file named "record_replay_cassette.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('localhost') do
-        puts "Response: " + Net::HTTP.get_response('localhost', '/', 7777).body
-      end
-      """
-    When I run `ruby record_replay_cassette.rb --with-server`
-    Then the output should contain "Response: Hello"
-    And the file "cassettes/localhost.yml" should contain "Hello"
-
-    When I run `ruby record_replay_cassette.rb`
-    Then the output should contain "Response: Hello"
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/configuration/cassette_library_dir.feature

@@ -1,31 +0,0 @@
-Feature: cassette_library_dir
-
-  The `cassette_library_dir` configuration option sets a directory
-  where VCR saves each cassette.
-
-  Note: When using Rails, avoid using the `test/fixtures` directory 
-  to store the cassettes. Rails treats any YAML file in the fixtures 
-  directory as an ActiveRecord fixture.
-  This will cause an `ActiveRecord::Fixture::FormatError` to be raised.
-
-  Scenario: cassette_library_dir
-    Given a file named "cassette_library_dir.rb" with:
-      """ruby
-      start_sinatra_app(:port => 7777) do
-        get('/') { "Hello" }
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.cassette_library_dir = 'vcr/cassettes'
-        c.hook_into :webmock
-      end
-
-      VCR.use_cassette('localhost') do
-        Net::HTTP.get_response('localhost', '/', 7777)
-      end
-      """
-     And the directory "vcr/cassettes" does not exist
-    When I run `ruby cassette_library_dir.rb`
-    Then the file "vcr/cassettes/localhost.yml" should exist

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/configuration/debug_logging.feature

@@ -1,52 +0,0 @@
-@exclude-18
-Feature: Debug Logging
-
-  Use the `debug_logger` option to set an IO-like object that VCR will log
-  debug output to. This is a useful way to troubleshoot what VCR is doing.
-
-  The debug logger must respond to `#puts`.
-
-  Scenario: Use the debug logger for troubleshooting
-    Given a file named "debug_logger.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.debug_logger = File.open(ARGV.first, 'w')
-      end
-
-      VCR.use_cassette('example') do
-        Net::HTTP.get_response(URI("http://localhost:7777/"))
-      end
-      """
-    When I run `ruby debug_logger.rb record.log --with-server`
-    Then the file "record.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :uri], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :uri] and 0 interaction(s): {  }
-      [webmock] Identified request type (recordable) for [get http://localhost:7777/]
-      [Cassette: 'example'] Recorded HTTP interaction [get http://localhost:7777/] => [200 "Hello World"]
-
-      """
-    When I run `ruby debug_logger.rb playback.log`
-    Then the file "playback.log" should contain exactly:
-      """
-      [Cassette: 'example'] Initialized with options: {:record=>:once, :match_requests_on=>[:method, :uri], :allow_unused_http_interactions=>true, :serialize_with=>:yaml, :persist_with=>:file_system}
-      [webmock] Handling request: [get http://localhost:7777/] (disabled: false)
-        [Cassette: 'example'] Initialized HTTPInteractionList with request matchers [:method, :uri] and 1 interaction(s): { [get http://localhost:7777/] => [200 "Hello World"] }
-        [Cassette: 'example'] Checking if [get http://localhost:7777/] matches [get http://localhost:7777/] using [:method, :uri]
-          [Cassette: 'example'] method (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-          [Cassette: 'example'] uri (matched): current request [get http://localhost:7777/] vs [get http://localhost:7777/]
-        [Cassette: 'example'] Found matching interaction for [get http://localhost:7777/] at index 0: [200 "Hello World"]
-      [webmock] Identified request type (stubbed_by_vcr) for [get http://localhost:7777/]
-
-      """

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/configuration/default_cassette_options.feature

@@ -1,100 +0,0 @@
-Feature: default_cassette_options
-
-  The `default_cassette_options` configuration option takes a hash
-  that provides defaults for each cassette you use.  Any cassette
-  can override the defaults as well as set additional options.
-
-  The `:match_requests_on` option defaults to `[:method, :uri]` when
-  it has not been set.
-
-  The `:record` option defaults to `:once` when it has not been set.
-
-  Background:
-    Given a file named "vcr_setup.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.default_cassette_options = { :record => :new_episodes, :erb => true }
-
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-      """
-
-  Scenario: cassettes get default values from configured `default_cassette_options`
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: new_episodes
-      ERB: true
-      """
-
-  Scenario: `:match_requests_on` defaults to `[:method, :uri]` when it has not been set
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example') do
-        puts "Match Requests On: #{VCR.current_cassette.match_requests_on.inspect}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Match Requests On: [:method, :uri]"
-
-  Scenario: `:record` defaults to `:once` when it has not been set
-    Given a file named "default_record_mode.rb" with:
-      """ruby
-      require 'vcr'
-
-      VCR.configure do |c|
-        # not important for this example, but must be set to something
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example') do
-        puts "Record mode: #{VCR.current_cassette.record_mode.inspect}"
-      end
-      """
-    When I run `ruby default_record_mode.rb`
-    Then the output should contain "Record mode: :once"
-
-  Scenario: cassettes can set their own options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :re_record_interval => 10000) do
-        puts "Re-record Interval: #{VCR.current_cassette.re_record_interval}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain "Re-record Interval: 10000"
-
-  Scenario: cassettes can override default options
-    Given a file named "default_cassette_options.rb" with:
-      """ruby
-      require 'vcr_setup.rb'
-
-      VCR.use_cassette('example', :record => :none, :erb => false) do
-        puts "Record Mode: #{VCR.current_cassette.record_mode}"
-        puts "ERB: #{VCR.current_cassette.erb}"
-      end
-      """
-    When I run `ruby default_cassette_options.rb`
-    Then the output should contain:
-      """
-      Record Mode: none
-      ERB: false
-      """

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/configuration/filter_sensitive_data.feature

@@ -1,152 +0,0 @@
-Feature: Filter sensitive data
-
-  Note: this config option is also available as `define_cassette_placeholder`
-  to reflect the fact that it is useful for more than just sensitive data.
-
-  The `filter_sensitive_data` configuration option can be used to prevent
-  sensitive data from being written to your cassette files.  This may be
-  important if you commit your cassettes files to source control and do
-  not want your sensitive data exposed.  Pass the following arguments to
-  `filter_sensitive_data`:
-
-    - A substitution string.  This is the string that will be written to
-      the cassettte file as a placeholder.  It should be unique and you
-      may want to wrap it in special characters like `{ }` or `< >`.
-    - A symbol specifying a tag (optional).  If a tag is given, the
-      filtering will only be applied to cassettes with the given tag.
-    - A block.  The block should return the sensitive text that you want
-      replaced with the substitution string.  If your block accepts an
-      argument, the HTTP interaction will be yielded so that you can
-      dynamically specify the sensitive text based on the interaction
-      (see the last scenario for an example of this).
-
-  When the interactions are replayed, the sensitive text will replace the
-  substitution string so that the interaction will be identical to what was
-  originally recorded.
-
-  You can specify as many filterings as you want.
-
-  Scenario: Multiple filterings
-    Given a file named "filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<GREETING>') { 'Hello' }
-        c.filter_sensitive_data('<LOCATION>') { 'World' }
-      end
-
-      VCR.use_cassette('filtering') do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Response: #{response.body}"
-      end
-      """
-    When I run `ruby filtering.rb --with-server`
-    Then the output should contain "Response: Hello World"
-     And the file "cassettes/filtering.yml" should contain "<GREETING> <LOCATION>"
-     And the file "cassettes/filtering.yml" should not contain "Hello"
-     And the file "cassettes/filtering.yml" should not contain "World"
-
-    When I run `ruby filtering.rb`
-    Then the output should contain "Hello World"
-
-  Scenario: Filter tagged cassettes
-    Given a file named "tagged_filtering.rb" with:
-      """ruby
-      if ARGV.include?('--with-server')
-        response_count = 0
-        start_sinatra_app(:port => 7777) do
-          get('/') { "Hello World #{response_count += 1 }" }
-        end
-      end
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<LOCATION>', :my_tag) { 'World' }
-      end
-
-      VCR.use_cassette('tagged', :tag => :my_tag) do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Tagged Response: #{response.body}"
-      end
-
-      VCR.use_cassette('untagged', :record => :new_episodes) do
-        response = Net::HTTP.get_response('localhost', '/', 7777)
-        puts "Untagged Response: #{response.body}"
-      end
-      """
-    When I run `ruby tagged_filtering.rb --with-server`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-     And the file "cassettes/tagged.yml" should contain "Hello <LOCATION> 1"
-     And the file "cassettes/untagged.yml" should contain "Hello World 2"
-
-    When I run `ruby tagged_filtering.rb`
-    Then the output should contain each of the following:
-      | Tagged Response: Hello World 1   |
-      | Untagged Response: Hello World 2 |
-
-  Scenario: Filter dynamic data based on yielded HTTP interaction
-    Given a file named "dynamic_filtering.rb" with:
-      """ruby
-      include_http_adapter_for('net/http')
-
-      if ARGV.include?('--with-server')
-        start_sinatra_app(:port => 7777) do
-          helpers do
-            def request_header_for(header_key_fragment)
-              key = env.keys.find { |k| k =~ /#{header_key_fragment}/i }
-              env[key]
-            end
-          end
-
-          get('/') { "#{request_header_for('username')}/#{request_header_for('password')}" }
-        end
-      end
-
-      require 'vcr'
-
-      USER_PASSWORDS = {
-        'john.doe' => 'monkey',
-        'jane.doe' => 'cheetah'
-      }
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.filter_sensitive_data('<PASSWORD>') do |interaction|
-          USER_PASSWORDS[interaction.request.headers['X-Http-Username'].first]
-        end
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:method, :uri, :headers]) do
-        puts "Response: " + response_body_for(
-          :get, 'http://localhost:7777/', nil,
-          'X-Http-Username' => 'john.doe',
-          'X-Http-Password' => USER_PASSWORDS['john.doe']
-        )
-      end
-      """
-    When I run `ruby dynamic_filtering.rb --with-server`
-    Then the output should contain "john.doe/monkey"
-    And the file "cassettes/example.yml" should contain "john.doe/<PASSWORD>"
-    And the file "cassettes/example.yml" should contain a YAML fragment like:
-      """
-      X-Http-Password:
-      - <PASSWORD>
-      """
-
-    When I run `ruby dynamic_filtering.rb`
-    Then the output should contain "john.doe/monkey"

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/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 }
-
-      start_sinatra_app(:port => 7777) do
-        get('/') { ARGV[0] }
-      end
-
-      puts "The response for request 1 was: #{response_body_for(:get, "http://localhost:7777/")}"
-
-      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:7777/")}"
-      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 }
-
-      start_sinatra_app(:port => 7777) do
-        get('/:path') { "#{ARGV[0]} #{params[:path]}" }
-      end
-
-      def net_http_response
-        Net::HTTP.get_response('localhost', '/net_http', 7777).body
-      end
-
-      def typhoeus_response
-        Typhoeus::Request.get("http://localhost:7777/typhoeus").body
-      end
-
-      def excon_response
-        Excon.get("http://localhost:7777/excon").body
-      end
-
-      def faraday_response
-        Faraday::Connection.new(:url => 'http://localhost:7777') 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' |