dwolla_swagger 1.0.6 → 1.0.7

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/request_matching/path.feature

@@ -1,96 +0,0 @@
-Feature: Matching on Path
-
-  Use the `:path` request matcher to match requests on the path portion
-  of the request URI.
-
-  You can use this (alone, or in combination with `:host`) as an
-  alternative to `:uri` so that non-deterministic portions of the URI
-  are not considered as part of the request matching.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://host1.com/about?date=2011-09-01
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "14"
-          body: 
-            encoding: UTF-8
-            string: about response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://host2.com/home?date=2011-09-01
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "15"
-          body: 
-            encoding: UTF-8
-            string: home response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Replay interaction that matches the path
-    And a file named "path_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:path]) do
-        puts "Response for /home: " + response_body_for(:get, "http://example.com/home")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:path]) do
-        puts "Response for /about: " + response_body_for(:get,  "http://example.com/about")
-      end
-      """
-    When I run `ruby path_matching.rb`
-    Then it should pass with:
-      """
-      Response for /home: home response
-      Response for /about: about response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/request_matching/playback_repeats.feature

@@ -1,98 +0,0 @@
-Feature: Playback repeats
-
-  By default, each response in a cassette can only be matched and played back
-  once while the cassette is in use (it can, of course, be re-used in multiple
-  tests, each of which should use the cassette separately). Note that this is
-  a change from the behavior in VCR 1.x. The old behavior occurred because of
-  how FakeWeb and WebMock behave internally and was not intended. Repeats create
-  less accurate tests since the real HTTP server may not necessarily return the
-  same response when identical requests are made in sequence.
-
-  If you want to allow playback repeats, VCR has a cassette option for this:
-
-      :allow_playback_repeats => true
-
-  @exclude-jruby
-  Scenario: Responses do not repeat by default
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 1
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "10"
-          body: 
-            encoding: UTF-8
-            string: Response 2
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-    And a file named "playback_repeats.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      puts "== With :allow_playback_repeats =="
-      VCR.use_cassette('example', :allow_playback_repeats => true) do
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-      end
-
-      puts "\n== Without :allow_playback_repeats =="
-      VCR.use_cassette('example') do
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-        puts response_body_for(:get, 'http://example.com/foo')
-      end
-      """
-    When I run `ruby playback_repeats.rb`
-    Then it should fail with "An HTTP request has been made that VCR does not know how to handle"
-     And the output should contain:
-      """
-      == With :allow_playback_repeats ==
-      Response 1
-      Response 2
-      Response 2
-
-      == Without :allow_playback_repeats ==
-      Response 1
-      Response 2
-      """

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/request_matching/query.feature

@@ -1,97 +0,0 @@
-Feature: Matching on Query string
-
-  Use the `:query` request matcher to match requests on the query string
-  portion of the request URI.
-
-  You can use this (alone, or in combination with others) as an
-  alternative to `:uri` so that non-deterministic portions of the URI
-  are not considered as part of the request matching.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      ---
-      http_interactions:
-      - request:
-          method: post
-          uri: http://host1.com/query?date=2011-09-01
-          body:
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "19"
-          body:
-            encoding: UTF-8
-            string: 2011-09-01 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request:
-          method: post
-          uri: http://host1.com/query?date=2011-09-02
-          body:
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response:
-          status:
-            code: 200
-            message: OK
-          headers:
-            Content-Length:
-            - "19"
-          body:
-            encoding: UTF-8
-            string: 2011-09-02 response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Replay interaction that matches the query string
-    And a file named "query_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.default_cassette_options = { :match_requests_on => [:query] }
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:query]) do
-        puts "Response for 2011-09-01 /query: " + response_body_for(:get, "http://example.com/query?date=2011-09-01")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:query]) do
-        puts "Response for 2011-09-02 /query: " + response_body_for(:get,  "http://example.com/query?date=2011-09-02")
-      end
-      """
-    When I run `ruby query_matching.rb`
-    Then it should pass with:
-      """
-      Response for 2011-09-01 /query: 2011-09-01 response
-      Response for 2011-09-02 /query: 2011-09-02 response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/request_matching/uri.feature

@@ -1,94 +0,0 @@
-Feature: Matching on URI
-
-  Use the `:uri` request matcher to match requests on the request URI.
-
-  The `:uri` matcher is used (along with the `:method` matcher) by default
-  if you do not specify how requests should match.
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: post
-          uri: http://example.com/foo
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: foo response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: post
-          uri: http://example.com/bar
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: bar response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario Outline: Replay interaction that matches the request URI
-    And a file named "uri_matching.rb" with:
-      """ruby
-      include_http_adapter_for("<http_lib>")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        <configuration>
-        c.cassette_library_dir = 'cassettes'
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:uri]) do
-        puts "Response for /bar: " + response_body_for(:get, "http://example.com/bar")
-      end
-
-      VCR.use_cassette('example', :match_requests_on => [:uri]) do
-        puts "Response for /foo: " + response_body_for(:get,  "http://example.com/foo")
-      end
-      """
-    When I run `ruby uri_matching.rb`
-    Then it should pass with:
-      """
-      Response for /bar: bar response
-      Response for /foo: foo response
-      """
-
-    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) |
-      | c.hook_into :faraday  | faraday (w/ typhoeus) |
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/request_matching/uri_without_param.feature

@@ -1,101 +0,0 @@
-Feature: URI without param(s)
-
-  A common source of difficulty when using VCR with the default matchers
-  are non-deterministic URIs. If the URI changes on every test run (because
-  it includes a timestamp parameter, or whatever), the default URI matcher
-  will not work well for you.
-
-  You can write a custom matcher to match URIs however you want, but for the
-  common need to match on a URI and ignore particular query parameters, VCR
-  provides an easier way:
-
-      :match_requests_on => [
-        :method,
-        VCR.request_matchers.uri_without_param(:timestamp)
-      ]
-
-  `uri_without_param` also has a plural alias (i.e. `uri_without_params(:timestamp, :session)`)
-
-  Background:
-    Given a previously recorded cassette file "cassettes/example.yml" with:
-      """
-      --- 
-      http_interactions: 
-      - request: 
-          method: get
-          uri: http://example.com/search?q=foo&timestamp=1316920490
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: foo response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      - request: 
-          method: get
-          uri: http://example.com/search?q=bar&timestamp=1296723437
-          body: 
-            encoding: UTF-8
-            string: ""
-          headers: {}
-        response: 
-          status: 
-            code: 200
-            message: OK
-          headers: 
-            Content-Length: 
-            - "12"
-          body: 
-            encoding: UTF-8
-            string: bar response
-          http_version: "1.1"
-        recorded_at: Tue, 01 Nov 2011 04:58:44 GMT
-      recorded_with: VCR 2.0.0
-      """
-
-  Scenario: Match the URI on all but the timestamp query parameter
-    And a file named "uri_without_param_matcher.rb" with:
-      """ruby
-      include_http_adapter_for("net/http")
-
-      require 'vcr'
-
-      VCR.configure do |c|
-        c.hook_into :webmock
-        c.cassette_library_dir = 'cassettes'
-        c.default_cassette_options = {
-          :match_requests_on => [:method,
-            VCR.request_matchers.uri_without_param(:timestamp)]
-        }
-      end
-
-      def search_uri(q)
-        "http://example.com/search?q=#{q}&timestamp=#{Time.now.to_i}"
-      end
-
-      VCR.use_cassette('example') do
-        puts "Response for bar: " +
-             response_body_for(:get, search_uri("bar"))
-      end
-
-      VCR.use_cassette('example') do
-        puts "Response for foo: " +
-             response_body_for(:get, search_uri("foo"))
-      end
-      """
-    When I run `ruby uri_without_param_matcher.rb`
-    Then it should pass with:
-      """
-      Response for bar: bar response
-      Response for foo: foo response
-      """
-

data/vendor/bundle/ruby/2.2.0/gems/vcr-2.9.3/features/step_definitions/cli_steps.rb

@@ -1,201 +0,0 @@
-require 'vcr'
-require 'multi_json'
-
-module VCRHelpers
-
-  def normalize_cassette_hash(cassette_hash)
-    cassette_hash['recorded_with'] = "VCR #{VCR.version}"
-    cassette_hash['http_interactions'].map! { |h| normalize_http_interaction(h) }
-    cassette_hash
-  end
-
-  def normalize_headers(object)
-    object.headers = {} and return if object.headers.nil?
-    object.headers = {}.tap do |hash|
-      object.headers.each do |key, value|
-        hash[key.downcase] = value
-      end
-    end
-  end
-
-  def static_timestamp
-    @static_timestamp ||= Time.now
-  end
-
-  def normalize_http_interaction(hash)
-    VCR::HTTPInteraction.from_hash(hash).tap do |i|
-      normalize_headers(i.request)
-      normalize_headers(i.response)
-
-      i.recorded_at &&= static_timestamp
-      i.request.body ||= ''
-      i.response.body ||= ''
-      i.response.status.message ||= ''
-      i.response.adapter_metadata.clear
-
-      # Remove non-deterministic headers and headers
-      # that get added by a particular HTTP library (but not by others)
-      i.response.headers.reject! { |k, v| %w[ server date connection ].include?(k) }
-      i.request.headers.reject! { |k, v| %w[ accept user-agent connection expect date ].include?(k) }
-
-      # Some HTTP libraries include an extra space ("OK " instead of "OK")
-      i.response.status.message = i.response.status.message.strip
-
-      if @scenario_parameters.to_s =~ /excon|faraday/
-        # Excon/Faraday do not expose the status message or http version,
-        # so we have no way to record these attributes.
-        i.response.status.message = nil
-        i.response.http_version = nil
-      elsif @scenario_parameters.to_s.include?('webmock')
-        # WebMock does not expose the HTTP version so we have no way to record it
-        i.response.http_version = nil
-      end
-    end
-  end
-
-  def normalize_cassette_content(content)
-    return content unless @scenario_parameters.to_s.include?('patron')
-    cassette_hash = YAML.load(content)
-    cassette_hash['http_interactions'].map! do |hash|
-      VCR::HTTPInteraction.from_hash(hash).tap do |i|
-        i.request.headers = (i.request.headers || {}).merge!('Expect' => [''])
-      end.to_hash
-    end
-    YAML.dump(cassette_hash)
-  end
-
-  def modify_file(file_name, orig_text, new_text)
-    in_current_dir do
-      file = File.read(file_name)
-      regex = /#{Regexp.escape(orig_text)}/
-      file.should =~ regex
-
-      file = file.gsub(regex, new_text)
-      File.open(file_name, 'w') { |f| f.write(file) }
-    end
-  end
-
-  def redis
-    @redis ||= begin
-       require 'redis'
-       Redis.connect
-    end
-  end
-end
-World(VCRHelpers)
-
-Given /the following files do not exist:/ do |files|
-  check_file_presence(files.raw.map{|file_row| file_row[0]}, false)
-end
-
-Given /^the directory "([^"]*)" does not exist$/ do |dir|
-  check_directory_presence([dir], false)
-end
-
-Given /^a previously recorded cassette file "([^"]*)" with:$/ do |file_name, content|
-  write_file(file_name, normalize_cassette_content(content))
-end
-
-Given /^it is (.*)$/ do |date_string|
-  set_env('DATE_STRING', date_string)
-end
-
-Given /^the redis DB has no data$/ do
-  redis.flushdb
-end
-
-When /^I modify the file "([^"]*)" to replace "([^"]*)" with "([^"]*)"$/ do |file_name, orig_text, new_text|
-  modify_file(file_name, orig_text, new_text)
-end
-
-When /^I append to file "([^"]*)":$/ do |file_name, content|
-  append_to_file(file_name, "\n" + content)
-end
-
-When /^I set the "([^"]*)" environment variable to "([^"]*)"$/ do |var, value|
-  set_env(var, value)
-end
-
-Then /^the file "([^"]*)" should exist$/ do |file_name|
-  check_file_presence([file_name], true)
-end
-
-Then /^it should (pass|fail) with "([^"]*)"$/ do |pass_fail, partial_output|
-  assert_exit_status_and_partial_output(pass_fail == 'pass', partial_output)
-end
-
-Then /^it should (pass|fail) with an error like:$/ do |pass_fail, partial_output|
-  assert_success(pass_fail == 'pass')
-
-  # different implementations place the exception class at different
-  # places relative to the message (i.e. with a multiline error message)
-  process_output = all_output.gsub(/\s*\(VCR::Errors::\w+\)/, '')
-
-  # Some implementations include extra leading spaces, for some reason...
-  process_output.gsub!(/^\s*/, '')
-  partial_output.gsub!(/^\s*/, '')
-
-  assert_partial_output(partial_output, process_output)
-end
-
-Then /^the output should contain each of the following:$/ do |table|
-  table.raw.flatten.each do |string|
-    assert_partial_output(string, all_output)
-  end
-end
-
-Then /^the file "([^"]*)" should contain YAML like:$/ do |file_name, expected_content|
-  actual_content = in_current_dir { File.read(file_name) }
-  normalize_cassette_hash(YAML.load(actual_content)).should == normalize_cassette_hash(YAML.load(expected_content))
-end
-
-Then /^the file "([^"]*)" should contain JSON like:$/ do |file_name, expected_content|
-  actual_content = in_current_dir { File.read(file_name) }
-  actual = MultiJson.decode(actual_content)
-  expected = MultiJson.decode(expected_content)
-  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
-end
-
-Then /^the file "([^"]*)" should contain ruby like:$/ do |file_name, expected_content|
-  actual_content = in_current_dir { File.read(file_name) }
-  actual = eval(actual_content)
-  expected = eval(expected_content)
-  normalize_cassette_hash(actual).should == normalize_cassette_hash(expected)
-end
-
-Then /^the file "([^"]*)" should contain each of these:$/ do |file_name, table|
-  table.raw.flatten.each do |string|
-    check_file_content(file_name, string, true)
-  end
-end
-
-Then /^the file "([^"]*)" should contain a YAML fragment like:$/ do |file_name, fragment|
-  in_current_dir do
-    file_content = File.read(file_name)
-
-    # Normalize by removing leading and trailing whitespace...
-    file_content = file_content.split("\n").map do |line|
-      # Different versions of psych use single vs. double quotes
-      # And then 2.1 sometimes adds quotes...
-      line.strip.gsub('"', "'").gsub("'", '')
-    end.join("\n")
-
-    file_content.should include(fragment.gsub("'", ''))
-  end
-end
-
-Then /^the cassette "([^"]*)" should have the following response bodies:$/ do |file, table|
-  interactions = in_current_dir { YAML.load_file(file) }['http_interactions'].map { |h| VCR::HTTPInteraction.from_hash(h) }
-  actual_response_bodies = interactions.map { |i| i.response.body }
-  expected_response_bodies = table.raw.flatten
-  actual_response_bodies.should =~ expected_response_bodies
-end
-
-Then /^the value stored at the redis key "([^"]*)" should include "([^"]*)"$/ do |key, value_fragment|
-  redis.get(key).should include(value_fragment)
-end
-
-Then /^it should (pass|fail)$/ do |pass_fail|
-  assert_success(pass_fail == 'pass')
-end
-