faraday 0.14.0 → 0.17.6

data/test/adapters/test_middleware_test.rb

@@ -0,0 +1,157 @@
+require File.expand_path('../../helper', __FILE__)
+
+module Adapters
+  class TestMiddleware < Faraday::TestCase
+    Stubs = Faraday::Adapter.lookup_middleware(:test)::Stubs
+    def setup
+      @stubs = Stubs.new do |stub|
+        stub.get('/hello') do
+          [200, {'Content-Type' => 'text/html'}, 'hello']
+        end
+        stub.get('/method-echo') do |env|
+          [200, {'Content-Type' => 'text/html'}, env[:method].to_s]
+        end
+        stub.get(/\A\/resources\/\d+(?:\?|\z)/) do
+          [200, {'Content-Type' => 'text/html'}, 'show']
+        end
+        stub.get(/\A\/resources\/(specified)\z/) do |env, meta|
+          [200, {'Content-Type' => 'text/html'}, "show #{meta[:match_data][1]}"]
+        end
+        stub.get('http://domain.test/hello') do
+          [200, {'Content-Type' => 'text/html'}, 'domain: hello']
+        end
+        stub.get('http://wrong.test/hello') do
+          [200, {'Content-Type' => 'text/html'}, 'wrong: hello']
+        end
+        stub.get('http://wrong.test/bait') do
+          [404, {'Content-Type' => 'text/html'}]
+        end
+      end
+      @conn  = Faraday.new do |builder|
+        builder.adapter :test, @stubs
+      end
+      @resp = @conn.get('/hello')
+    end
+
+    def test_middleware_with_simple_path_sets_status
+      assert_equal 200, @resp.status
+    end
+
+    def test_middleware_with_simple_path_sets_headers
+      assert_equal 'text/html', @resp.headers['Content-Type']
+    end
+
+    def test_middleware_with_simple_path_sets_body
+      assert_equal 'hello', @resp.body
+    end
+
+    def test_middleware_with_host_points_to_the_right_stub
+      assert_equal 'domain: hello', @conn.get('http://domain.test/hello').body
+    end
+
+    def test_middleware_can_be_called_several_times
+      assert_equal 'hello', @conn.get('/hello').body
+    end
+
+    def test_middleware_can_handle_regular_expression_path
+      assert_equal 'show', @conn.get('/resources/1').body
+    end
+
+    def test_middleware_can_handle_single_parameter_block
+      assert_equal 'get', @conn.get('/method-echo').body
+    end
+
+    def test_middleware_can_handle_regular_expression_path_with_captured_result
+      assert_equal 'show specified', @conn.get('/resources/specified').body
+    end
+
+    def test_middleware_with_get_params
+      @stubs.get('/param?a=1') { [200, {}, 'a'] }
+      assert_equal 'a', @conn.get('/param?a=1').body
+    end
+
+    def test_middleware_ignores_unspecified_get_params
+      @stubs.get('/optional?a=1') { [200, {}, 'a'] }
+      assert_equal 'a', @conn.get('/optional?a=1&b=1').body
+      assert_equal 'a', @conn.get('/optional?a=1').body
+      assert_raises Faraday::Adapter::Test::Stubs::NotFound do
+        @conn.get('/optional')
+      end
+    end
+
+    def test_middleware_with_http_headers
+      @stubs.get('/yo', { 'X-HELLO' => 'hello' }) { [200, {}, 'a'] }
+      @stubs.get('/yo') { [200, {}, 'b'] }
+      assert_equal 'a', @conn.get('/yo') { |env| env.headers['X-HELLO'] = 'hello' }.body
+      assert_equal 'b', @conn.get('/yo').body
+    end
+
+    def test_middleware_allow_different_outcomes_for_the_same_request
+      @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'hello'] }
+      @stubs.get('/hello') { [200, {'Content-Type' => 'text/html'}, 'world'] }
+      assert_equal 'hello', @conn.get("/hello").body
+      assert_equal 'world', @conn.get("/hello").body
+    end
+
+    def test_yields_env_to_stubs
+      @stubs.get '/hello' do |env|
+        assert_equal '/hello',     env[:url].path
+        assert_equal 'foo.com',    env[:url].host
+        assert_equal '1',          env[:params]['a']
+        assert_equal 'text/plain', env[:request_headers]['Accept']
+        [200, {}, 'a']
+      end
+
+      @conn.headers['Accept'] = 'text/plain'
+      assert_equal 'a', @conn.get('http://foo.com/hello?a=1').body
+    end
+
+    def test_parses_params_with_default_encoder
+      @stubs.get '/hello' do |env|
+        assert_equal '1', env[:params]['a']['b']
+        [200, {}, 'a']
+      end
+
+      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
+    end
+
+    def test_parses_params_with_nested_encoder
+      @stubs.get '/hello' do |env|
+        assert_equal '1', env[:params]['a']['b']
+        [200, {}, 'a']
+      end
+
+      @conn.options.params_encoder = Faraday::NestedParamsEncoder
+      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
+    end
+
+    def test_parses_params_with_flat_encoder
+      @stubs.get '/hello' do |env|
+        assert_equal '1', env[:params]['a[b]']
+        [200, {}, 'a']
+      end
+
+      @conn.options.params_encoder = Faraday::FlatParamsEncoder
+      assert_equal 'a', @conn.get('http://foo.com/hello?a[b]=1').body
+    end
+
+    def test_raises_an_error_if_no_stub_is_found_for_request
+      assert_raises Stubs::NotFound do
+        @conn.get('/invalid'){ [200, {}, []] }
+      end
+    end
+
+    def test_raises_an_error_if_no_stub_is_found_for_specified_host
+      assert_raises Stubs::NotFound do
+        @conn.get('http://domain.test/bait')
+      end
+    end
+
+    def test_raises_an_error_if_no_stub_is_found_for_request_without_this_header
+      @stubs.get('/yo', { 'X-HELLO' => 'hello' }) { [200, {}, 'a'] }
+      assert_raises Faraday::Adapter::Test::Stubs::NotFound do
+        @conn.get('/yo')
+      end
+    end
+  end
+end

data/test/adapters/typhoeus_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../integration', __FILE__)
+
+module Adapters
+  class TyphoeusTest < Faraday::TestCase
+
+    def adapter() :typhoeus end
+
+    Integration.apply(self, :Parallel) do
+      # inconsistent outcomes ranging from successful response to connection error
+      undef :test_proxy_auth_fail if ssl_mode?
+
+      # Typhoeus adapter not supporting Faraday::SSLError
+      undef :test_GET_ssl_fails_with_bad_cert if ssl_mode?
+
+      def test_binds_local_socket
+        host = '1.2.3.4'
+        conn = create_connection :request => { :bind => { :host => host } }
+        assert_equal host, conn.options[:bind][:host]
+      end
+
+      # Typhoeus::Response doesn't provide an easy way to access the reason phrase,
+      # so override the shared test from Common.
+      def test_GET_reason_phrase
+        response = get('echo')
+        assert_nil response.reason_phrase
+      end
+    end
+
+    def test_custom_adapter_config
+      adapter = Faraday::Adapter::Typhoeus.new(nil, { :forbid_reuse => true, :maxredirs => 1 })
+
+      request = adapter.method(:typhoeus_request).call({})
+
+      assert_equal true, request.options[:forbid_reuse]
+      assert_equal 1, request.options[:maxredirs]
+    end
+  end
+end

data/test/authentication_middleware_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path('../helper', __FILE__)
+
+class AuthenticationMiddlewareTest < Faraday::TestCase
+  def conn
+    Faraday::Connection.new('http://example.net/') do |builder|
+      yield(builder)
+      builder.adapter :test do |stub|
+        stub.get('/auth-echo') do |env|
+          [200, {}, env[:request_headers]['Authorization']]
+        end
+      end
+    end
+  end
+
+  def test_basic_middleware_adds_basic_header
+    response = conn { |b| b.request :basic_auth, 'aladdin', 'opensesame' }.get('/auth-echo')
+    assert_equal 'Basic YWxhZGRpbjpvcGVuc2VzYW1l', response.body
+  end
+
+  def test_basic_middleware_adds_basic_header_correctly_with_long_values
+    response = conn { |b| b.request :basic_auth, 'A' * 255, '' }.get('/auth-echo')
+    assert_equal "Basic #{'QUFB' * 85}Og==", response.body
+  end
+
+  def test_basic_middleware_does_not_interfere_with_existing_authorization
+    response = conn { |b| b.request :basic_auth, 'aladdin', 'opensesame' }.
+      get('/auth-echo', nil, :authorization => 'Token token="bar"')
+    assert_equal 'Token token="bar"', response.body
+  end
+
+  def test_token_middleware_adds_token_header
+    response = conn { |b| b.request :token_auth, 'quux' }.get('/auth-echo')
+    assert_equal 'Token token="quux"', response.body
+  end
+
+  def test_token_middleware_includes_other_values_if_provided
+    response = conn { |b|
+      b.request :token_auth, 'baz', :foo => 42
+    }.get('/auth-echo')
+    assert_match(/^Token /, response.body)
+    assert_match(/token="baz"/, response.body)
+    assert_match(/foo="42"/, response.body)
+  end
+
+  def test_token_middleware_does_not_interfere_with_existing_authorization
+    response = conn { |b| b.request :token_auth, 'quux' }.
+      get('/auth-echo', nil, :authorization => 'Token token="bar"')
+    assert_equal 'Token token="bar"', response.body
+  end
+
+  def test_authorization_middleware_with_string
+    response = conn { |b|
+      b.request :authorization, 'custom', 'abc def'
+    }.get('/auth-echo')
+    assert_match(/^custom abc def$/, response.body)
+  end
+
+  def test_authorization_middleware_with_hash
+    response = conn { |b|
+      b.request :authorization, 'baz', :foo => 42
+    }.get('/auth-echo')
+    assert_match(/^baz /, response.body)
+    assert_match(/foo="42"/, response.body)
+  end
+end

data/test/composite_read_io_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'stringio'
+
+class CompositeReadIOTest < Faraday::TestCase
+  Part = Struct.new(:to_io) do
+    def length() to_io.string.length end
+  end
+
+  def part(str)
+    Part.new StringIO.new(str)
+  end
+
+  def composite_io(*parts)
+    Faraday::CompositeReadIO.new(*parts)
+  end
+
+  def test_empty
+    io = composite_io
+    assert_equal 0, io.length
+    assert_equal "", io.read
+  end
+
+  def test_empty_returns_nil_for_limited_read
+    assert_nil composite_io.read(1)
+  end
+
+  def test_empty_parts_returns_nil_for_limited_read
+    io = composite_io(part(""), part(""))
+    assert_nil io.read(1)
+  end
+
+  def test_multipart_read_all
+    io = composite_io(part("abcd"), part("1234"))
+    assert_equal 8, io.length
+    assert_equal "abcd1234", io.read
+  end
+
+  def test_multipart_read_limited
+    io = composite_io(part("abcd"), part("1234"))
+    assert_equal "abc", io.read(3)
+    assert_equal "d12", io.read(3)
+    assert_equal "34", io.read(3)
+    assert_nil io.read(3)
+    assert_nil io.read(3)
+  end
+
+  def test_multipart_read_limited_size_larger_than_part
+    io = composite_io(part("abcd"), part("1234"))
+    assert_equal "abcd12", io.read(6)
+    assert_equal "34", io.read(6)
+    assert_nil io.read(6)
+  end
+
+  def test_multipart_read_with_blank_parts
+    io = composite_io(part(""), part("abcd"), part(""), part("1234"), part(""))
+    assert_equal "abcd12", io.read(6)
+    assert_equal "34", io.read(6)
+    assert_nil io.read(6)
+  end
+
+  def test_multipart_rewind
+    io = composite_io(part("abcd"), part("1234"))
+    assert_equal "abc", io.read(3)
+    assert_equal "d12", io.read(3)
+    io.rewind
+    assert_equal "abc", io.read(3)
+    assert_equal "d1234", io.read(5)
+    assert_nil io.read(3)
+    io.rewind
+    assert_equal "ab", io.read(2)
+  end
+
+  # JRuby enforces types to copy_stream to be String or IO
+  if IO.respond_to?(:copy_stream) && !jruby?
+    def test_compatible_with_copy_stream
+      target_io = StringIO.new
+      def target_io.ensure_open_and_writable
+        # Rubinius compatibility
+      end
+      io = composite_io(part("abcd"), part("1234"))
+
+      Faraday::Timer.timeout(1) do
+        IO.copy_stream(io, target_io)
+      end
+      assert_equal "abcd1234", target_io.string
+    end
+  end
+
+  def test_read_from_multibyte
+    File.open(File.dirname(__FILE__) + '/multibyte.txt') do |utf8|
+      io = composite_io(part("\x86"), Part.new(utf8))
+      assert_equal bin("\x86\xE3\x83\x95\xE3\x82\xA1\xE3\x82\xA4\xE3\x83\xAB\n"), io.read
+    end
+  end
+
+  def test_limited_from_multibyte
+    File.open(File.dirname(__FILE__) + '/multibyte.txt') do |utf8|
+      io = composite_io(part("\x86"), Part.new(utf8))
+      assert_equal bin("\x86\xE3\x83"), io.read(3)
+      assert_equal bin("\x95\xE3\x82"), io.read(3)
+      assert_equal bin("\xA1\xE3\x82\xA4\xE3\x83\xAB\n"), io.read(8)
+    end
+  end
+
+  def bin(str)
+    str.force_encoding("BINARY") if str.respond_to?(:force_encoding)
+    str
+  end
+end