faraday 0.17.3 → 1.2.0

data/test/request_middleware_test.rb

@@ -1,126 +0,0 @@
-# encoding: utf-8
-require File.expand_path('../helper', __FILE__)
-
-Faraday::CompositeReadIO.class_eval { attr_reader :ios }
-
-class RequestMiddlewareTest < Faraday::TestCase
-  def conn
-    Faraday.new do |b|
-      b.request :multipart
-      b.request :url_encoded
-      b.adapter :test do |stub|
-        stub.post('/echo') do |env|
-          posted_as = env[:request_headers]['Content-Type']
-          [200, {'Content-Type' => posted_as}, env[:body]]
-        end
-      end
-    end
-  end
-
-  def test_does_nothing_without_payload
-    response = conn.post('/echo')
-    assert_nil response.headers['Content-Type']
-    assert response.body.empty?
-  end
-
-  def test_ignores_custom_content_type
-    response = conn.post('/echo', { :some => 'data' }, 'content-type' => 'application/x-foo')
-    assert_equal 'application/x-foo', response.headers['Content-Type']
-    assert_equal({ :some => 'data' }, response.body)
-  end
-
-  def test_url_encoded_no_header
-    response = conn.post('/echo', { :fruit => %w[apples oranges] })
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    assert_equal 'fruit%5B%5D=apples&fruit%5B%5D=oranges', response.body
-  end
-
-  def test_url_encoded_with_header
-    response = conn.post('/echo', {'a'=>123}, 'content-type' => 'application/x-www-form-urlencoded')
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    assert_equal 'a=123', response.body
-  end
-
-  def test_url_encoded_nested
-    response = conn.post('/echo', { :user => {:name => 'Mislav', :web => 'mislav.net'} })
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    expected = { 'user' => {'name' => 'Mislav', 'web' => 'mislav.net'} }
-    assert_equal expected, Faraday::Utils.parse_nested_query(response.body)
-  end
-
-  def test_url_encoded_non_nested
-    response = conn.post('/echo', { :dimensions => ['date', 'location']}) do |req|
-      req.options.params_encoder = Faraday::FlatParamsEncoder
-    end
-    assert_equal 'application/x-www-form-urlencoded', response.headers['Content-Type']
-    expected = { 'dimensions' => ['date', 'location'] }
-    assert_equal expected, Faraday::Utils.parse_query(response.body)
-    assert_equal 'dimensions=date&dimensions=location', response.body
-  end
-
-  def test_url_encoded_unicode
-    err = capture_warnings {
-      response = conn.post('/echo', {:str => "eé cç aã aâ"})
-      assert_equal "str=e%C3%A9+c%C3%A7+a%C3%A3+a%C3%A2", response.body
-    }
-    assert err.empty?, "stderr did include: #{err}"
-  end
-
-  def test_url_encoded_nested_keys
-    response = conn.post('/echo', {'a'=>{'b'=>{'c'=>['d']}}})
-    assert_equal "a%5Bb%5D%5Bc%5D%5B%5D=d", response.body
-  end
-
-  def test_multipart
-    # assume params are out of order
-    regexes = [
-      /name\=\"a\"/,
-      /name=\"b\[c\]\"\; filename\=\"request_middleware_test\.rb\"/,
-      /name=\"b\[d\]\"/]
-
-    payload = {:a => 1, :b => {:c => Faraday::UploadIO.new(__FILE__, 'text/x-ruby'), :d => 2}}
-    response = conn.post('/echo', payload)
-
-    assert_kind_of Faraday::CompositeReadIO, response.body
-    assert response.headers['Content-Type'].start_with?(
-      "multipart/form-data; boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY_PREFIX,
-    )
-
-    response.body.send(:ios).map{|io| io.read}.each do |io|
-      if re = regexes.detect { |r| io =~ r }
-        regexes.delete re
-      end
-    end
-    assert_equal [], regexes
-  end
-
-  def test_multipart_with_arrays
-    # assume params are out of order
-    regexes = [
-      /name\=\"a\"/,
-      /name=\"b\[\]\[c\]\"\; filename\=\"request_middleware_test\.rb\"/,
-      /name=\"b\[\]\[d\]\"/]
-
-    payload = {:a => 1, :b =>[{:c => Faraday::UploadIO.new(__FILE__, 'text/x-ruby'), :d => 2}]}
-    response = conn.post('/echo', payload)
-
-    assert_kind_of Faraday::CompositeReadIO, response.body
-    assert response.headers['Content-Type'].start_with?(
-      "multipart/form-data; boundary=%s" % Faraday::Request::Multipart::DEFAULT_BOUNDARY_PREFIX,
-    )
-
-    response.body.send(:ios).map{|io| io.read}.each do |io|
-      if re = regexes.detect { |r| io =~ r }
-        regexes.delete re
-      end
-    end
-    assert_equal [], regexes
-  end
-
-  def test_multipart_unique_boundary
-    payload = {:a => 1, :b =>[{:c => Faraday::UploadIO.new(__FILE__, 'text/x-ruby'), :d => 2}]}
-    response1 = conn.post('/echo', payload)
-    response2 = conn.post('/echo', payload)
-    assert response1.headers['Content-Type'] != response2.headers['Content-Type']
-  end
-end

data/test/response_middleware_test.rb

@@ -1,72 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class ResponseMiddlewareTest < Faraday::TestCase
-  def setup
-    @conn = Faraday.new do |b|
-      b.response :raise_error
-      b.adapter :test do |stub|
-        stub.get('ok')        { [200, {'Content-Type' => 'text/html'}, '<body></body>'] }
-        stub.get('not-found') { [404, {'X-Reason' => 'because'}, 'keep looking'] }
-        stub.get('error')     { [500, {'X-Error' => 'bailout'}, 'fail'] }
-      end
-    end
-  end
-
-  class ResponseUpcaser < Faraday::Response::Middleware
-    def parse(body)
-      body.upcase
-    end
-  end
-
-  def test_success
-    assert @conn.get('ok')
-  end
-
-  def test_raises_not_found
-    error = assert_raises Faraday::ResourceNotFound do
-      @conn.get('not-found')
-    end
-    assert_equal 'the server responded with status 404', error.message
-    assert_equal 'because', error.response[:headers]['X-Reason']
-  end
-
-  def test_raises_error
-    error = assert_raises Faraday::ClientError do
-      @conn.get('error')
-    end
-    assert_equal 'the server responded with status 500', error.message
-    assert_equal 'bailout', error.response[:headers]['X-Error']
-  end
-
-  def test_upcase
-    @conn.builder.insert(0, ResponseUpcaser)
-    assert_equal '<BODY></BODY>', @conn.get('ok').body
-  end
-end
-
-class ResponseNoBodyMiddleWareTest < Faraday::TestCase
-  def setup
-    @conn = Faraday.new do |b|
-      b.response :raise_error
-      b.adapter :test do |stub|
-        stub.get('not_modified') { [304, nil, nil] }
-        stub.get('no_content') { [204, nil, nil] }
-      end
-    end
-    @conn.builder.insert(0, NotCalled)
-  end
-
-  class NotCalled < Faraday::Response::Middleware
-    def parse(body)
-      raise "this should not be called"
-    end
-  end
-
-  def test_204
-    assert_nil @conn.get('no_content').body
-  end
-
-  def test_304
-    assert_nil @conn.get('not_modified').body
-  end
-end

data/test/strawberry.rb

@@ -1,2 +0,0 @@
-class MiddlewareStackTest::Strawberry < MiddlewareStackTest::Handler
-end

data/test/utils_test.rb

@@ -1,98 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-class TestUtils < Faraday::TestCase
-
-  # Headers parsing
-
-  def test_headers
-    "HTTP/1.x 500 OK\r\nContent-Type: text/html; charset=UTF-8\r\n" \
-    "HTTP/1.x 200 OK\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n"
-  end
-
-  def test_headers_parsing_for_aggregated_responses
-    headers = Faraday::Utils::Headers.new()
-    headers.parse(test_headers)
-
-    result = headers.to_hash
-
-    assert_equal result["Content-Type"], "application/json; charset=UTF-8"
-  end
-
-  # URI parsing
-
-  def setup
-    @url = "http://example.com/abc"
-  end
-
-  # emulates ActiveSupport::SafeBuffer#gsub
-  FakeSafeBuffer = Struct.new(:string) do
-    def to_s() self end
-    def gsub(regex)
-      string.gsub(regex) {
-        match, = $&, '' =~ /a/
-        yield(match)
-      }
-    end
-  end
-
-  def test_escaping_safe_buffer
-    str = FakeSafeBuffer.new('$32,000.00')
-    assert_equal '%2432%2C000.00', Faraday::Utils.escape(str)
-  end
-
-  def test_parses_with_default
-    with_default_uri_parser(nil) do
-      uri = normalize(@url)
-      assert_equal 'example.com', uri.host
-    end
-  end
-
-  def test_parses_with_URI
-    with_default_uri_parser(::URI) do
-      uri = normalize(@url)
-      assert_equal 'example.com', uri.host
-    end
-  end
-
-  def test_parses_with_block
-    with_default_uri_parser(lambda {|u| "booya#{"!" * u.size}" }) do
-      assert_equal 'booya!!!!!!!!!!!!!!!!!!!!!!', normalize(@url)
-    end
-  end
-
-  def test_replace_header_hash
-    headers = Faraday::Utils::Headers.new('authorization' => 't0ps3cr3t!')
-    assert headers.include?('authorization')
-
-    headers.replace({'content-type' => 'text/plain'})
-
-    assert !headers.include?('authorization')
-  end
-
-  def normalize(url)
-    Faraday::Utils::URI(url)
-  end
-
-  def with_default_uri_parser(parser)
-    old_parser = Faraday::Utils.default_uri_parser
-    begin
-      Faraday::Utils.default_uri_parser = parser
-      yield
-    ensure
-      Faraday::Utils.default_uri_parser = old_parser
-    end
-  end
-
-  # YAML parsing
-
-  def test_headers_yaml_roundtrip
-    headers = Faraday::Utils::Headers.new('User-Agent' => 'safari', 'Content-type' => 'text/html')
-    result = YAML.load(headers.to_yaml)
-
-    assert result.include?('user-agent'), 'Unable to hydrate to a correct Headers'
-    assert result.include?('content-type'), 'Unable to hydrate to a correct Headers'
-    assert result['user-agent'] == 'safari', 'Unable to access rehydrated Headers'
-    assert result['content-type'] == 'text/html', 'Unable to access rehydrated Headers'
-  end
-end
-