faraday 0.17.3 → 1.2.0

data/test/middleware/retry_test.rb

@@ -1,282 +0,0 @@
-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

@@ -1,260 +0,0 @@
-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