faraday 0.17.0 → 0.17.1

data/test/middleware/retry_test.rb

@@ -0,0 +1,282 @@
+require File.expand_path("../../helper", __FILE__)
+
+module Middleware
+  class RetryTest < Faraday::TestCase
+    def setup
+      @times_called = 0
+      @envs = []
+    end
+
+    def conn(*retry_args)
+      Faraday.new do |b|
+        b.request :retry, *retry_args
+
+        b.adapter :test do |stub|
+          ['get', 'post'].each do |method|
+            stub.send(method, '/unstable') do |env|
+              @times_called += 1
+              @envs << env.dup
+              env[:body] = nil # simulate blanking out response body
+              @explode.call @times_called
+            end
+
+            stub.send(method, '/throttled') do |env|
+              @times_called += 1
+              @envs << env.dup
+
+              params = env[:params]
+
+              status = (params['status'] || 429).to_i
+              headers = {}
+
+              retry_after = params['retry_after']
+
+              headers['Retry-After'] = retry_after if retry_after
+
+              [status, headers, '']
+            end
+          end
+        end
+      end
+    end
+
+    def test_unhandled_error
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) { conn.get("/unstable") }
+      assert_equal 1, @times_called
+    end
+
+    def test_handled_error
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn.get("/unstable") }
+      assert_equal 3, @times_called
+    end
+
+    def test_legacy_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(1).get("/unstable") }
+      assert_equal 2, @times_called
+    end
+
+    def test_legacy_max_negative_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(-9).get("/unstable") }
+      assert_equal 1, @times_called
+    end
+
+    def test_new_max_retries
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => 3).get("/unstable") }
+      assert_equal 4, @times_called
+    end
+
+    def test_new_max_negative_retries
+      @explode = lambda { |n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) { conn(:max => -9).get("/unstable") }
+      assert_equal 1, @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).get("/unstable")
+      }
+      assert_in_delta 0.2, Time.now - started, 0.04
+    end
+
+    def test_calls_calculate_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 calculate_sleep_amount(retries, env)
+          self.sleep_amount_retries.delete(retries)
+          0
+        end
+      end
+      retry_middleware.sleep_amount_retries = [2, 1]
+
+      assert_raises(Errno::ETIMEDOUT) {
+        retry_middleware.call({:method => :get})
+      }
+
+      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.send(:calculate_retry_interval, 5), 0.1
+      assert_equal middleware.send(:calculate_retry_interval, 4), 0.2
+      assert_equal middleware.send(:calculate_retry_interval, 3), 0.4
+    end
+
+    def test_exponential_backoff_with_max_interval
+      middleware = Faraday::Request::Retry.new(nil, :max => 5, :interval => 1, :max_interval => 3, :backoff_factor => 2)
+      assert_equal middleware.send(:calculate_retry_interval, 5), 1
+      assert_equal middleware.send(:calculate_retry_interval, 4), 2
+      assert_equal middleware.send(:calculate_retry_interval, 3), 3
+      assert_equal middleware.send(:calculate_retry_interval, 2), 3
+    end
+
+    def test_random_additional_interval_amount
+      middleware = Faraday::Request::Retry.new(nil, :max => 2, :interval => 0.1, :interval_randomness => 1.0)
+      sleep_amount = middleware.send(:calculate_retry_interval, 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.send(:calculate_retry_interval, 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.send(:calculate_retry_interval, 2)
+      assert_operator sleep_amount, :>=, 0.1
+      assert_operator sleep_amount, :<=, 0.125
+    end
+
+    def test_custom_exceptions
+      @explode = lambda {|n| raise "boom!" }
+      assert_raises(RuntimeError) {
+        conn(:exceptions => StandardError).get("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+
+    def test_should_retry_with_body_if_block_returns_true_for_non_idempotent_request
+      body = { :foo => :bar }
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| true }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable", body)
+      }
+      assert_equal 3, @times_called
+      assert @envs.all? { |env| env[:body] === body }
+    end
+
+    def test_should_stop_retrying_if_block_returns_false_checking_env
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| env[:method] != :post }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_stop_retrying_if_block_returns_false_checking_exception
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| !exception.kind_of?(Errno::ETIMEDOUT) }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_not_call_retry_if_for_idempotent_methods_if_methods_unspecified
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| raise "this should have never been called" }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check).get("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+
+    def test_should_not_retry_for_non_idempotent_method_if_methods_unspecified
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn.post("/unstable")
+      }
+      assert_equal 1, @times_called
+    end
+
+    def test_should_not_call_retry_if_for_specified_methods
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| raise "this should have never been called" }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check, :methods => [:post]).post("/unstable")
+      }
+      assert_equal 3, @times_called
+    end
+
+    def test_should_call_retry_if_for_empty_method_list
+      @explode = lambda {|n| raise Errno::ETIMEDOUT }
+      check = lambda { |env,exception| @times_called < 2 }
+      assert_raises(Errno::ETIMEDOUT) {
+        conn(:retry_if => check, :methods => []).get("/unstable")
+      }
+      assert_equal 2, @times_called
+    end
+
+    def test_should_rewind_files_on_retry
+      io = StringIO.new("Test data")
+      upload_io = Faraday::UploadIO.new(io, "application/octet/stream")
+
+      rewound = 0
+      rewind = lambda { rewound += 1 }
+
+      upload_io.stub :rewind, rewind do
+        @explode = lambda {|n| raise Errno::ETIMEDOUT }
+        check = lambda { |env,exception| true }
+        assert_raises(Errno::ETIMEDOUT) {
+          conn(:retry_if => check).post("/unstable", { :file => upload_io })
+        }
+      end
+      assert_equal 3, @times_called
+      assert_equal 2, rewound
+    end
+
+    def test_should_retry_retriable_response
+      params = { status: 429 }
+      response = conn(:max => 1, :retry_statuses => 429).get("/throttled", params)
+
+      assert_equal 2, @times_called
+      assert_equal 429, response.status
+    end
+
+    def test_should_not_retry_non_retriable_response
+      params = { status: 503 }
+      conn(:max => 1, :retry_statuses => 429).get("/throttled", params)
+
+      assert_equal 1, @times_called
+    end
+
+    def test_interval_if_retry_after_present
+      started = Time.now
+
+      params = { :retry_after => 0.5 }
+      conn(:max => 1, :interval => 0.1, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 0.5
+    end
+
+    def test_should_ignore_retry_after_if_less_then_calculated
+      started = Time.now
+
+      params = { :retry_after => 0.1 }
+      conn(:max => 1, :interval => 0.2, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 0.2
+    end
+
+    def test_interval_when_retry_after_is_timestamp
+      started = Time.now
+
+      params = { :retry_after => (Time.now.utc + 2).strftime('%a, %d %b %Y %H:%M:%S GMT') }
+      conn(:max => 1, :interval => 0.1, :retry_statuses => [429]).get("/throttled", params)
+
+      assert Time.now - started > 1
+    end
+
+    def test_should_not_retry_when_retry_after_greater_then_max_interval
+      params = { :retry_after => (Time.now.utc + 20).strftime('%a, %d %b %Y %H:%M:%S GMT') }
+      conn(:max => 2, :interval => 0.1, :retry_statuses => [429], max_interval: 5).get("/throttled", params)
+
+      assert_equal 1, @times_called
+    end
+  end
+end

data/test/middleware_stack_test.rb

@@ -0,0 +1,260 @@
+require File.expand_path('../helper', __FILE__)
+
+class MiddlewareStackTest < Faraday::TestCase
+  # mock handler classes
+  class Handler < Struct.new(:app)
+    def call(env)
+      (env[:request_headers]['X-Middleware'] ||= '') << ":#{self.class.name.split('::').last}"
+      app.call(env)
+    end
+  end
+  class Apple < Handler; end
+  class Orange < Handler; end
+  class Banana < Handler; end
+
+  class Broken < Faraday::Middleware
+    dependency 'zomg/i_dont/exist'
+  end
+
+  def setup
+    @conn = Faraday::Connection.new
+    @builder = @conn.builder
+  end
+
+  def test_sets_default_adapter_if_none_set
+    default_middleware = Faraday::Request.lookup_middleware :url_encoded
+    default_adapter_klass = Faraday::Adapter.lookup_middleware Faraday.default_adapter
+    assert @builder[0] == default_middleware
+    assert @builder[1] == default_adapter_klass
+  end
+
+  def test_allows_rebuilding
+    build_stack Apple
+    build_stack Orange
+    assert_handlers %w[Orange]
+  end
+
+  def test_allows_extending
+    build_handlers_stack Apple
+    @builder.use Orange
+    @builder.adapter :test, &test_adapter
+    assert_handlers %w[Apple Orange]
+  end
+
+  def test_builder_is_passed_to_new_faraday_connection
+    new_conn = Faraday::Connection.new :builder => @builder
+    assert_equal @builder, new_conn.builder
+  end
+
+  def test_insert_before
+    build_handlers_stack Apple, Orange
+    @builder.insert_before Apple, Banana
+    @builder.adapter :test, &test_adapter
+    assert_handlers %w[Banana Apple Orange]
+  end
+
+  def test_insert_after
+    build_handlers_stack Apple, Orange
+    @builder.insert_after Apple, Banana
+    @builder.adapter :test, &test_adapter
+    assert_handlers %w[Apple Banana Orange]
+  end
+
+  def test_swap_handlers
+    build_handlers_stack Apple, Orange
+    @builder.swap Apple, Banana
+    @builder.adapter :test, &test_adapter
+    assert_handlers %w[Banana Orange]
+  end
+
+  def test_delete_handler
+    build_stack Apple, Orange
+    @builder.delete Apple
+    assert_handlers %w[Orange]
+  end
+
+  def test_stack_is_locked_after_making_requests
+    build_stack Apple
+    assert !@builder.locked?
+    @conn.get('/')
+    assert @builder.locked?
+
+    assert_raises Faraday::RackBuilder::StackLocked do
+      @conn.use Orange
+    end
+  end
+
+  def test_duped_stack_is_unlocked
+    build_stack Apple
+    assert !@builder.locked?
+    @builder.lock!
+    assert @builder.locked?
+
+    duped_connection = @conn.dup
+    assert_equal @builder, duped_connection.builder
+    assert !duped_connection.builder.locked?
+  end
+
+  def test_handler_comparison
+    build_stack Apple
+    assert_equal @builder.handlers.first, Apple
+    assert_equal @builder.handlers[0,1], [Apple]
+    assert_equal @builder.handlers.first, Faraday::RackBuilder::Handler.new(Apple)
+  end
+
+  def test_unregistered_symbol
+    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::Middleware.register_middleware :apple => Apple
+    begin
+      build_stack :apple
+      assert_handlers %w[Apple]
+    ensure
+      unregister_middleware Faraday::Middleware, :apple
+    end
+  end
+
+  def test_registered_symbol_with_proc
+    Faraday::Middleware.register_middleware :apple => lambda { Apple }
+    begin
+      build_stack :apple
+      assert_handlers %w[Apple]
+    ensure
+      unregister_middleware Faraday::Middleware, :apple
+    end
+  end
+
+  def test_registered_symbol_with_array
+    Faraday::Middleware.register_middleware File.expand_path("..", __FILE__),
+      :strawberry => [lambda { Strawberry }, 'strawberry']
+    begin
+      build_stack :strawberry
+      assert_handlers %w[Strawberry]
+    ensure
+      unregister_middleware Faraday::Middleware, :strawberry
+    end
+  end
+
+  def test_missing_dependencies
+    build_stack Broken
+    err = assert_raises RuntimeError do
+      @conn.get('/')
+    end
+    assert_match "missing dependency for MiddlewareStackTest::Broken: ", err.message
+    assert_match "zomg/i_dont/exist", err.message
+  end
+
+  def test_env_stored_on_middleware_response_has_reference_to_the_response
+    env = response = nil
+    build_stack Struct.new(:app) {
+      define_method(:call) { |e| env, response = e, app.call(e) }
+    }
+    @conn.get("/")
+    assert_same env.response, response.env.response
+  end
+
+  private
+
+  # make a stack with test adapter that reflects the order of middleware
+  def build_stack(*handlers)
+    @builder.build do |b|
+      handlers.each { |handler| b.use(*handler) }
+      yield(b) if block_given?
+
+      @builder.adapter :test, &test_adapter
+    end
+  end
+
+  def build_handlers_stack(*handlers)
+    @builder.build do |b|
+      handlers.each { |handler| b.use(*handler) }
+    end
+  end
+
+  def test_adapter
+    Proc.new do |stub|
+      stub.get '/' do |env|
+        # echo the "X-Middleware" request header in the body
+        [200, {}, env[:request_headers]['X-Middleware'].to_s]
+      end
+    end
+  end
+
+  def assert_handlers(list)
+    echoed_list = @conn.get('/').body.to_s.split(':')
+    echoed_list.shift if echoed_list.first == ''
+    assert_equal list, echoed_list
+  end
+
+  def unregister_middleware(component, key)
+    # TODO: unregister API?
+    component.instance_variable_get('@registered_middleware').delete(key)
+  end
+end
+
+class MiddlewareStackOrderTest < Faraday::TestCase
+  def test_adding_response_middleware_after_adapter
+    response_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.response :raise_error
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &response_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter
+    request_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.request :multipart
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &request_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter_via_use
+    use_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.use Faraday::Request::Multipart
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &use_after_adapter)
+  end
+
+  def test_adding_request_middleware_after_adapter_via_insert
+    insert_after_adapter = lambda do
+      Faraday::RackBuilder.new do |b|
+        b.adapter :test
+        b.insert(1, Faraday::Request::Multipart)
+      end
+    end
+
+    assert_output("", expected_middleware_warning, &insert_after_adapter)
+  end
+
+  def test_adding_request_middleware_before_adapter_via_insert_no_warning
+    builder = Faraday::RackBuilder.new do |b|
+      b.adapter :test
+    end
+
+    insert_before_adapter = lambda do
+      builder.insert(0, Faraday::Request::Multipart)
+    end
+
+    assert_output("", "", &insert_before_adapter)
+  end
+
+  private
+
+  def expected_middleware_warning
+    /Unexpected middleware set after the adapter/
+  end
+end