Class: Middleware::RetryTest

Inherits:
Faraday::TestCase show all
Defined in:
test/middleware/retry_test.rb

Instance Method Summary collapse

Methods inherited from Faraday::TestCase

#capture_warnings, jruby?, rbx?, ssl_mode?, #test_default

Methods included from Faraday::LiveServerConfig

#live_server, #live_server=, #live_server?

Instance Method Details

#conn(*retry_args) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
 
# File 'test/middleware/retry_test.rb', line 9

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

#setup ⇒ Object 



5
6
7
 
# File 'test/middleware/retry_test.rb', line 5

def setup
  @times_called = 0
end

#test_calls_sleep_amount ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'test/middleware/retry_test.rb', line 54

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

#test_custom_exceptions ⇒ Object 



101
102
103
104
105
106
107
 
# File 'test/middleware/retry_test.rb', line 101

def test_custom_exceptions
  @explode = lambda {|n| raise "boom!" }
  assert_raises(RuntimeError) {
    conn(:exceptions => StandardError).post("/unstable")
  }
  assert_equal 3, @times_called
end

#test_exponential_backoff ⇒ Object 



79
80
81
82
83
84
 
# File 'test/middleware/retry_test.rb', line 79

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

#test_handled_error ⇒ Object 



27
28
29
30
31
 
# File 'test/middleware/retry_test.rb', line 27

def test_handled_error
  @explode = lambda {|n| raise Errno::ETIMEDOUT }
  assert_raises(Errno::ETIMEDOUT) { conn.post("/unstable") }
  assert_equal 3, @times_called
end

#test_interval ⇒ Object 



45
46
47
48
49
50
51
52
 
# File 'test/middleware/retry_test.rb', line 45

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

#test_legacy_max_retries ⇒ Object 



33
34
35
36
37
 
# File 'test/middleware/retry_test.rb', line 33

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

#test_new_max_retries ⇒ Object 



39
40
41
42
43
 
# File 'test/middleware/retry_test.rb', line 39

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

#test_random_additional_interval_amount ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'test/middleware/retry_test.rb', line 86

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

#test_unhandled_error ⇒ Object 



21
22
23
24
25
 
# File 'test/middleware/retry_test.rb', line 21

def test_unhandled_error
  @explode = lambda {|n| raise "boom!" }
  assert_raises(RuntimeError) { conn.post("/unstable") }
  assert_equal 1, @times_called
end