faraday 0.8.11 → 0.9.0

data/test/middleware/instrumentation_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path("../../helper", __FILE__)
+
+module Middleware
+  class InstrumentationTest < Faraday::TestCase
+    def setup
+      @instrumenter = FakeInstrumenter.new
+    end
+
+    def test_default_name
+      assert_equal 'request.faraday', options.name
+    end
+
+    def test_default_instrumenter
+      begin
+        instrumenter = options.instrumenter
+      rescue NameError => err
+        assert_match 'ActiveSupport', err.to_s
+      else
+        assert_equal ActiveSupport::Notifications, instrumenter
+      end
+    end
+
+    def test_name
+      assert_equal 'booya', options(:name => 'booya').name
+    end
+
+    def test_instrumenter
+      assert_equal :boom, options(:instrumenter => :boom).instrumenter
+    end
+
+    def test_instrumentation_with_default_name
+      assert_equal 0, @instrumenter.instrumentations.size
+
+      faraday = conn
+      res = faraday.get '/'
+      assert_equal 'ok', res.body
+
+      assert_equal 1, @instrumenter.instrumentations.size
+      name, env = @instrumenter.instrumentations.first
+      assert_equal 'request.faraday', name
+      assert_equal '/', env[:url].path
+    end
+
+    def test_instrumentation
+      assert_equal 0, @instrumenter.instrumentations.size
+
+      faraday = conn :name => 'booya'
+      res = faraday.get '/'
+      assert_equal 'ok', res.body
+
+      assert_equal 1, @instrumenter.instrumentations.size
+      name, env = @instrumenter.instrumentations.first
+      assert_equal 'booya', name
+      assert_equal '/', env[:url].path
+    end
+
+    class FakeInstrumenter
+      attr_reader :instrumentations
+
+      def initialize
+        @instrumentations = []
+      end
+
+      def instrument(name, env)
+        @instrumentations << [name, env]
+        yield
+      end
+    end
+
+    def options(hash = nil)
+      Faraday::Request::Instrumentation::Options.from hash
+    end
+
+    def conn(hash = nil)
+      hash ||= {}
+      hash[:instrumenter] = @instrumenter
+
+      Faraday.new do |f|
+        f.request :instrumentation, hash
+        f.adapter :test do |stub|
+          stub.get '/' do
+            [200, {}, 'ok']
+          end
+        end
+      end
+    end
+  end
+end

data/test/middleware/retry_test.rb

@@ -1,56 +1,109 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
+require File.expand_path("../../helper", __FILE__)
 
 module Middleware
   class RetryTest < Faraday::TestCase
     def setup
-      @stubs = Faraday::Adapter::Test::Stubs.new
-      @conn = Faraday.new do |b|
-        b.request :retry, 2
-        b.use ContentValidator
-        b.adapter :test, @stubs
-      end
+      @times_called = 0
     end
 
-    ContentValidator = Struct.new(:app) do
-      def call(env)
-        response = app.call(env)
-        type = response[:content_type]
-        raise "wrong content-type: %p" % type unless type == "application/json"
+    def conn(*retry_args)
+      Faraday.new do |b|
+        b.request :retry, *retry_args
+        b.adapter :test do |stub|
+          stub.post('/unstable') {
+            @times_called += 1
+            @explode.call @times_called
+          }
+        end
       end
     end
 
-    def test_retries
-      times_called = 0
+    def test_unhandled_error
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) { conn.post("/unstable") }
+      assert_equal 1, @times_called
+    end
 
-      @stubs.post("/echo") do
-        times_called += 1
-        [200, {}, "hello"]
-      end
+    def test_handled_error
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn.post("/unstable") }
+      assert_equal 3, @times_called
+    end
 
-      @conn.post("/echo") rescue nil
-      assert_equal times_called, 3
+    def test_legacy_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(1).post("/unstable") }
+      assert_equal 2, @times_called
     end
 
-    def test_retry_with_body
-      times_called = 0
-      bodies_received = []
+    def test_new_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).post("/unstable") }
+      assert_equal 4, @times_called
+    end
+
+    def test_interval
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      started  = Time.now
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:max => 2, :interval => 0.1).post("/unstable")
+      }
+      assert_in_delta 0.2, Time.now - started, 0.04
+    end
 
-      @stubs.post("/echo") do |env|
-        times_called += 1
-        bodies_received << env[:body]
-        if times_called < 2
-          [200, {"Content-type" => "text/plain"}, "hello"]
-        else
-          [200, {"Content-type" => "application/json"}, '{"message": "hello"}']
+    def test_calls_sleep_amount
+      explode_app = MiniTest::Mock.new
+      explode_app.expect(:call, nil, [{:body=>nil}])
+      def explode_app.call(env)
+        raise Errno::ETIMEDOUT
+      end
+
+      retry_middleware = Faraday::Request::Retry.new(explode_app)
+      class << retry_middleware
+        attr_accessor :sleep_amount_retries
+
+        def sleep_amount(retries)
+          self.sleep_amount_retries.delete(retries)
+          0
         end
       end
+      retry_middleware.sleep_amount_retries = [2, 1]
+
+      assert_raises(Errno::ETIMEDOUT) {
+        retry_middleware.call({})
+      }
+
+      assert_empty retry_middleware.sleep_amount_retries
+    end
+
+    def test_exponential_backoff
+      middleware = Faraday::Request::Retry.new(nil, :max => 5, :interval => 0.1, :backoff_factor => 2)
+      assert_equal middleware.sleep_amount(5), 0.1
+      assert_equal middleware.sleep_amount(4), 0.2
+      assert_equal middleware.sleep_amount(3), 0.4
+    end
 
-      body = {:foo => "bar"}
-      @conn.post("/echo", body)
+    def test_random_additional_interval_amount
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 1.0)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.2
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 0.5)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.15
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 0.25)
+      sleep_amount = middleware.sleep_amount(2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.125
+    end
 
-      assert_equal times_called, 2
-      assert_same body, bodies_received[0]
-      assert_same body, bodies_received[1]
+    def test_custom_exceptions
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) {
+        conn(:exceptions => StandardError).post("/unstable")
+      }
+      assert_equal 3, @times_called
     end
   end
 end

data/test/middleware_stack_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 class MiddlewareStackTest < Faraday::TestCase
   # mock handler classes
@@ -75,7 +75,7 @@ class MiddlewareStackTest < Faraday::TestCase
     @conn.get('/')
     assert @builder.locked?
 
-    assert_raises Faraday::Builder::StackLocked do
+    assert_raises Faraday::RackBuilder::StackLocked do
       @conn.use Orange
     end
   end
@@ -95,16 +95,16 @@ class MiddlewareStackTest < Faraday::TestCase
     build_stack Apple
     assert_equal @builder.handlers.first, Apple
     assert_equal @builder.handlers[0,1], [Apple]
-    assert_equal @builder.handlers.first, Faraday::Builder::Handler.new(Apple)
+    assert_equal @builder.handlers.first, Faraday::RackBuilder::Handler.new(Apple)
   end
 
   def test_unregistered_symbol
-    err = assert_raise(RuntimeError) { build_stack :apple }
+    err = assert_raises(Faraday::Error){ build_stack :apple }
     assert_equal ":apple is not registered on Faraday::Middleware", err.message
   end
 
   def test_registered_symbol
-    Faraday.register_middleware :apple => Apple
+    Faraday::Middleware.register_middleware :apple => Apple
     begin
       build_stack :apple
       assert_handlers %w[Apple]
@@ -114,7 +114,7 @@ class MiddlewareStackTest < Faraday::TestCase
   end
 
   def test_registered_symbol_with_proc
-    Faraday.register_middleware :apple => lambda { Apple }
+    Faraday::Middleware.register_middleware :apple => lambda { Apple }
     begin
       build_stack :apple
       assert_handlers %w[Apple]
@@ -123,13 +123,14 @@ class MiddlewareStackTest < Faraday::TestCase
     end
   end
 
-  def test_registered_symbol_with_type
-    Faraday.register_middleware :request, :orange => Orange
+  def test_registered_symbol_with_array
+    Faraday::Middleware.register_middleware File.expand_path("..", __FILE__),
+      :strawberry => [lambda { Strawberry }, 'strawberry']
     begin
-      build_stack {|b| b.request :orange }
-      assert_handlers %w[Orange]
+      build_stack :strawberry
+      assert_handlers %w[Strawberry]
     ensure
-      unregister_middleware Faraday::Request, :orange
+      unregister_middleware Faraday::Middleware, :strawberry
     end
   end
 
@@ -148,7 +149,7 @@ class MiddlewareStackTest < Faraday::TestCase
   def build_stack(*handlers)
     @builder.build do |b|
       handlers.each { |handler| b.use(*handler) }
-      yield b if block_given?
+      yield(b) if block_given?
 
       b.adapter :test do |stub|
         stub.get '/' do |env|

data/test/options_test.rb

@@ -0,0 +1,252 @@
+require File.expand_path('../helper', __FILE__)
+
+class OptionsTest < Faraday::TestCase
+  class SubOptions < Faraday::Options.new(:sub); end
+  class ParentOptions < Faraday::Options.new(:a, :b, :c)
+    options :c => SubOptions
+  end
+
+  def test_clear
+    options = SubOptions.new(1)
+    assert !options.empty?
+    assert options.clear
+    assert options.empty?
+  end
+
+  def test_empty
+    options = SubOptions.new
+    assert options.empty?
+    options.sub = 1
+    assert !options.empty?
+    options.delete(:sub)
+    assert options.empty?
+  end
+
+  def test_each_key
+    options = ParentOptions.new(1, 2, 3)
+    enum = options.each_key
+    assert_equal enum.next.to_sym, :a
+    assert_equal enum.next.to_sym, :b
+    assert_equal enum.next.to_sym, :c
+  end
+
+  def test_key?
+    options = SubOptions.new
+    assert !options.key?(:sub)
+    options.sub = 1
+    if RUBY_VERSION >= '1.9'
+      assert options.key?(:sub)
+    else
+      assert options.key?("sub")
+    end
+  end
+
+  def test_each_value
+    options = ParentOptions.new(1, 2, 3)
+    enum = options.each_value
+    assert_equal enum.next, 1
+    assert_equal enum.next, 2
+    assert_equal enum.next, 3
+  end
+
+  def test_value?
+    options = SubOptions.new
+    assert !options.value?(1)
+    options.sub = 1
+    assert options.value?(1)
+  end
+
+  def test_request_proxy_setter
+    options = Faraday::RequestOptions.new
+    assert_nil options.proxy
+
+    assert_raises NoMethodError do
+      options[:proxy] = {:booya => 1}
+    end
+
+    options[:proxy] = {:user => 'user'}
+    assert_kind_of Faraday::ProxyOptions, options.proxy
+    assert_equal 'user', options.proxy.user
+
+    options.proxy = nil
+    assert_nil options.proxy
+  end
+
+  def test_proxy_options_from_string
+    options = Faraday::ProxyOptions.from 'http://user:pass@example.org'
+    assert_equal 'user', options.user
+    assert_equal 'pass', options.password
+    assert_kind_of URI, options.uri
+    assert_equal '', options.path
+    assert_equal 80, options.port
+    assert_equal 'example.org', options.host
+    assert_equal 'http', options.scheme
+  end
+
+  def test_proxy_options_hash_access
+    proxy = Faraday::ProxyOptions.from 'http://a%40b:pw%20d@example.org'
+    assert_equal 'a@b', proxy[:user]
+    assert_equal 'a@b', proxy.user
+    assert_equal 'pw d', proxy[:password]
+    assert_equal 'pw d', proxy.password
+  end
+
+  def test_proxy_options_no_auth
+    proxy = Faraday::ProxyOptions.from 'http://example.org'
+    assert_nil proxy.user
+    assert_nil proxy.password
+  end
+
+  def test_from_options
+    options = ParentOptions.new(1)
+
+    value = ParentOptions.from(options)
+    assert_equal 1, value.a
+    assert_nil value.b
+  end
+
+  def test_from_options_with_sub_object
+    sub = SubOptions.new(1)
+    options = ParentOptions.from :a => 1, :c => sub
+    assert_kind_of ParentOptions, options
+    assert_equal 1, options.a
+    assert_nil options.b
+    assert_kind_of SubOptions, options.c
+    assert_equal 1, options.c.sub
+  end
+
+  def test_from_hash
+    options = ParentOptions.from :a => 1
+    assert_kind_of ParentOptions, options
+    assert_equal 1, options.a
+    assert_nil options.b
+  end
+
+  def test_from_hash_with_sub_object
+    options = ParentOptions.from :a => 1, :c => {:sub => 1}
+    assert_kind_of ParentOptions, options
+    assert_equal 1, options.a
+    assert_nil options.b
+    assert_kind_of SubOptions, options.c
+    assert_equal 1, options.c.sub
+  end
+
+  def test_inheritance
+    subclass = Class.new(ParentOptions)
+    options = subclass.from(:c => {:sub => 'hello'})
+    assert_kind_of SubOptions, options.c
+    assert_equal 'hello', options.c.sub
+  end
+
+  def test_from_deep_hash
+    hash = {:b => 1}
+    options = ParentOptions.from :a => hash
+    assert_equal 1, options.a[:b]
+
+    hash[:b] = 2
+    assert_equal 1, options.a[:b]
+
+    options.a[:b] = 3
+    assert_equal 2, hash[:b]
+    assert_equal 3, options.a[:b]
+  end
+
+  def test_from_nil
+    options = ParentOptions.from(nil)
+    assert_kind_of ParentOptions, options
+    assert_nil options.a
+    assert_nil options.b
+  end
+
+  def test_invalid_key
+    assert_raises NoMethodError do
+      ParentOptions.from :invalid => 1
+    end
+  end
+
+  def test_update
+    options = ParentOptions.new(1)
+    assert_equal 1, options.a
+    assert_nil options.b
+
+    updated = options.update :a => 2, :b => 3
+    assert_equal 2, options.a
+    assert_equal 3, options.b
+    assert_equal options, updated
+  end
+
+  def test_delete
+    options = ParentOptions.new(1)
+    assert_equal 1, options.a
+    assert_equal 1, options.delete(:a)
+    assert_nil options.a
+  end
+
+  def test_merge
+    options = ParentOptions.new(1)
+    assert_equal 1, options.a
+    assert_nil options.b
+
+    dup = options.merge :a => 2, :b => 3
+    assert_equal 2, dup.a
+    assert_equal 3, dup.b
+    assert_equal 1, options.a
+    assert_nil options.b
+  end
+
+  def test_env_access_member
+    e = Faraday::Env.new
+    assert_nil e.method
+    e.method = :get
+    assert_equal :get, e.method
+  end
+
+  def test_env_access_symbol_non_member
+    e = Faraday::Env.new
+    assert_nil e[:custom]
+    e[:custom] = :boom
+    assert_equal :boom, e[:custom]
+  end
+
+  def test_env_access_string_non_member
+    e = Faraday::Env.new
+    assert_nil e["custom"]
+    e["custom"] = :boom
+    assert_equal :boom, e["custom"]
+  end
+
+  def test_env_fetch_ignores_false
+    ssl = Faraday::SSLOptions.new
+    ssl.verify = false
+    assert !ssl.fetch(:verify, true)
+  end
+
+  def test_fetch_grabs_value
+    opt = Faraday::SSLOptions.new
+    opt.verify = 1
+    assert_equal 1, opt.fetch(:verify, false) { |k| :blah }
+  end
+
+  def test_fetch_uses_falsey_default
+    opt = Faraday::SSLOptions.new
+    assert_equal false, opt.fetch(:verify, false) { |k| :blah }
+  end
+
+  def test_fetch_accepts_block
+    opt = Faraday::SSLOptions.new
+    assert_equal "yo :verify", opt.fetch(:verify) { |k| "yo #{k.inspect}"}
+  end
+
+  def test_fetch_needs_a_default_if_key_is_missing
+    opt = Faraday::SSLOptions.new
+    assert_raises Faraday::Options.fetch_error_class do
+      opt.fetch :verify
+    end
+  end
+
+  def test_fetch_works_with_key
+    opt = Faraday::SSLOptions.new
+    opt.verify = 1
+    assert_equal 1, opt.fetch(:verify)
+  end
+end

data/test/request_middleware_test.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 Faraday::CompositeReadIO.class_eval { attr_reader :ios }
 
@@ -62,6 +62,16 @@ class RequestMiddlewareTest < Faraday::TestCase
     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â"})

data/test/response_middleware_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require File.expand_path('../helper', __FILE__)
 
 class ResponseMiddlewareTest < Faraday::TestCase
   def setup
@@ -19,9 +19,7 @@ class ResponseMiddlewareTest < Faraday::TestCase
   end
 
   def test_success
-    assert_nothing_raised do
-      @conn.get('ok')
-    end
+    assert @conn.get('ok')
   end
 
   def test_raises_not_found

data/test/strawberry.rb

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

data/test/utils_test.rb

@@ -1,6 +1,9 @@
 require File.expand_path('../helper', __FILE__)
 
 class TestUtils < Faraday::TestCase
+  def setup
+    @url = "http://example.com/abc"
+  end
 
   # emulates ActiveSupport::SafeBuffer#gsub
   FakeSafeBuffer = Struct.new(:string) do
@@ -8,7 +11,7 @@ class TestUtils < Faraday::TestCase
     def gsub(regex)
       string.gsub(regex) {
         match, = $&, '' =~ /a/
-        yield match
+        yield(match)
       }
     end
   end
@@ -18,13 +21,38 @@ class TestUtils < Faraday::TestCase
     assert_equal '%2432%2C000.00', Faraday::Utils.escape(str)
   end
 
-  def test_replace_header_hash
-    headers = Faraday::Utils::Headers.new('authorization' => 't0ps3cr3t!')
-    assert headers.include?('authorization')
+  def test_parses_with_default
+    with_default_uri_parser(nil) do
+      uri = normalize(@url)
+      assert_equal 'example.com', uri.host
+    end
+  end
 
-    headers.replace({'content-type' => 'text/plain'})
+  def test_parses_with_URI
+    with_default_uri_parser(::URI) do
+      uri = normalize(@url)
+      assert_equal 'example.com', uri.host
+    end
+  end
 
-    assert !headers.include?('authorization')
+  def test_parses_with_block
+    with_default_uri_parser(lambda {|u| "booya#{"!" * u.size}" }) do
+      assert_equal 'booya!!!!!!!!!!!!!!!!!!!!!!', normalize(@url)
+    end
+  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
 end