test/test_timeout.rb

   1 # frozen_string_literal: false
   2 require 'test/unit'
   3 require 'timeout'
   4
   5 class TestTimeout < Test::Unit::TestCase
   6
   7   def test_work_is_done_in_same_thread_as_caller
   8     assert_equal Thread.current, Timeout.timeout(10){ Thread.current }
   9   end
  10
  11   def test_work_is_done_in_same_fiber_as_caller
  12     require 'fiber' # needed for ruby 3.0 and lower
  13     assert_equal Fiber.current, Timeout.timeout(10){ Fiber.current }
  14   end
  15
  16   def test_non_timing_out_code_is_successful
  17     assert_nothing_raised do
  18       assert_equal :ok, Timeout.timeout(1){ :ok }
  19     end
  20   end
  21
  22   def test_allows_zero_seconds
  23     assert_nothing_raised do
  24       assert_equal :ok, Timeout.timeout(0){:ok}
  25     end
  26   end
  27
  28   def test_allows_nil_seconds
  29     assert_nothing_raised do
  30       assert_equal :ok, Timeout.timeout(nil){:ok}
  31     end
  32   end
  33
  34   def test_included
  35     c = Class.new do
  36       include Timeout
  37       def test
  38         timeout(1) { :ok }
  39       end
  40     end
  41     assert_nothing_raised do
  42       assert_equal :ok, c.new.test
  43     end
  44   end
  45
  46   def test_yield_param
  47     assert_equal [5, :ok], Timeout.timeout(5){|s| [s, :ok] }
  48   end
  49
  50   def test_queue
  51     q = Thread::Queue.new
  52     assert_raise(Timeout::Error, "[ruby-dev:32935]") {
  53       Timeout.timeout(0.01) { q.pop }
  54     }
  55   end
  56
  57   def test_timeout
  58     assert_raise(Timeout::Error) do
  59       Timeout.timeout(0.1) {
  60         nil while true
  61       }
  62     end
  63   end
  64
  65   def test_nested_timeout
  66     a = nil
  67     assert_raise(Timeout::Error) do
  68       Timeout.timeout(0.1) {
  69         Timeout.timeout(1) {
  70           nil while true
  71         }
  72         a = 1
  73       }
  74     end
  75     assert_nil a
  76   end
  77
  78   class MyNewErrorOuter < StandardError; end
  79   class MyNewErrorInner < StandardError; end
  80
  81   # DOES NOT fail with
  82   # -        raise new(message) if exc.equal?(e)
  83   # +        raise new(message) if exc.class == e.class
  84   def test_nested_timeout_error_identity
  85     begin
  86       Timeout.timeout(0.1, MyNewErrorOuter) {
  87         Timeout.timeout(1, MyNewErrorInner) {
  88           nil while true
  89         }
  90       }
  91     rescue => e
  92       assert e.class == MyNewErrorOuter
  93     end
  94   end
  95
  96   # DOES fail with
  97   # -        raise new(message) if exc.equal?(e)
  98   # +        raise new(message) if exc.class == e.class
  99   def test_nested_timeout_which_error_bubbles_up
 100     raised_exception = nil
 101     begin
 102       Timeout.timeout(0.1) {
 103         Timeout.timeout(1) {
 104           raise Timeout::ExitException.new("inner message")
 105         }
 106       }
 107     rescue Exception => e
 108       raised_exception = e
 109     end
 110
 111     assert_equal 'inner message', raised_exception.message
 112   end
 113
 114   def test_cannot_convert_into_time_interval
 115     bug3168 = '[ruby-dev:41010]'
 116     def (n = Object.new).zero?; false; end
 117     assert_raise(TypeError, bug3168) {Timeout.timeout(n) { sleep 0.1 }}
 118   end
 119
 120   def test_skip_rescue_standarderror
 121     e = nil
 122     assert_raise_with_message(Timeout::Error, /execution expired/) do
 123       Timeout.timeout 0.01 do
 124         begin
 125           sleep 3
 126         rescue => e
 127           flunk "should not see any exception but saw #{e.inspect}"
 128         end
 129       end
 130     end
 131   end
 132
 133   def test_raises_exception_internally
 134     e = nil
 135     assert_raise_with_message(Timeout::Error, /execution expired/) do
 136       Timeout.timeout 0.01 do
 137         begin
 138           sleep 3
 139         rescue Exception => exc
 140           e = exc
 141           raise
 142         end
 143       end
 144     end
 145     assert_equal Timeout::ExitException, e.class
 146   end
 147
 148   def test_rescue_exit
 149     exc = Class.new(RuntimeError)
 150     e = nil
 151     assert_nothing_raised(exc) do
 152       Timeout.timeout 0.01, exc do
 153         begin
 154           sleep 3
 155         rescue exc => e
 156         end
 157       end
 158     end
 159     assert_raise_with_message(exc, 'execution expired') {raise e if e}
 160   end
 161
 162   def test_custom_exception
 163     bug9354 = '[ruby-core:59511] [Bug #9354]'
 164     err = Class.new(StandardError) do
 165       def initialize(msg) super end
 166     end
 167     assert_nothing_raised(ArgumentError, bug9354) do
 168       assert_equal(:ok, Timeout.timeout(100, err) {:ok})
 169     end
 170     assert_raise_with_message(err, 'execution expired') do
 171       Timeout.timeout 0.01, err do
 172         sleep 3
 173       end
 174     end
 175     assert_raise_with_message(err, /connection to ruby-lang.org expired/) do
 176       Timeout.timeout 0.01, err, "connection to ruby-lang.org expired" do
 177         sleep 3
 178       end
 179     end
 180   end
 181
 182   def test_exit_exception
 183     assert_raise_with_message(Timeout::Error, "boon") do
 184       Timeout.timeout(10, Timeout::Error) do
 185         raise Timeout::Error, "boon"
 186       end
 187     end
 188   end
 189
 190   def test_raise_with_message
 191     bug17812 = '[ruby-core:103502] [Bug #17812]: Timeout::Error doesn\'t let two-argument raise() set a new message'
 192     exc = Timeout::Error.new('foo')
 193     assert_raise_with_message(Timeout::Error, 'bar', bug17812) do
 194       raise exc, 'bar'
 195     end
 196   end
 197
 198   def test_enumerator_next
 199     bug9380 = '[ruby-dev:47872] [Bug #9380]: timeout in Enumerator#next'
 200     e = (o=Object.new).to_enum
 201     def o.each
 202       sleep
 203     end
 204     assert_raise_with_message(Timeout::Error, 'execution expired', bug9380) do
 205       Timeout.timeout(0.01) {e.next}
 206     end
 207   end
 208
 209   def test_handle_interrupt
 210     bug11344 = '[ruby-dev:49179] [Bug #11344]'
 211     ok = false
 212     assert_raise(Timeout::Error) {
 213       Thread.handle_interrupt(Timeout::ExitException => :never) {
 214         Timeout.timeout(0.01) {
 215           sleep 0.2
 216           ok = true
 217           Thread.handle_interrupt(Timeout::ExitException => :on_blocking) {
 218             sleep 0.2
 219           }
 220         }
 221       }
 222     }
 223     assert(ok, bug11344)
 224   end
 225
 226   def test_fork
 227     omit 'fork not supported' unless Process.respond_to?(:fork)
 228     r, w = IO.pipe
 229     pid = fork do
 230       r.close
 231       begin
 232         r = Timeout.timeout(0.01) { sleep 5 }
 233         w.write r.inspect
 234       rescue Timeout::Error
 235         w.write 'timeout'
 236       ensure
 237         w.close
 238       end
 239     end
 240     w.close
 241     Process.wait pid
 242     assert_equal 'timeout', r.read
 243     r.close
 244   end
 245
 246   def test_threadgroup
 247     assert_separately(%w[-rtimeout], <<-'end;')
 248       tg = ThreadGroup.new
 249       thr = Thread.new do
 250         tg.add(Thread.current)
 251         Timeout.timeout(10){}
 252       end
 253       thr.join
 254       assert_equal [].to_s, tg.list.to_s
 255     end;
 256   end
 257
 258   # https://github.com/ruby/timeout/issues/24
 259   def test_handling_enclosed_threadgroup
 260     assert_separately(%w[-rtimeout], <<-'end;')
 261       Thread.new {
 262         t = Thread.current
 263         group = ThreadGroup.new
 264         group.add(t)
 265         group.enclose
 266
 267         assert_equal 42, Timeout.timeout(1) { 42 }
 268       }.join
 269     end;
 270   end
 271 end