[tests] Improve reliability of pool wait sleep tests

Author: chadlwilson

src/spec/ruby/rack/application_spec.rb

@@ -512,7 +512,7 @@ def reset_config
 
 describe org.jruby.rack.rails.RailsRackApplicationFactory do
 
-  java_import org.jruby.rack.rails.RailsRackApplicationFactory
+  require 'jruby/rack/rails_booter'
 
   before :each do
     @app_factory = RailsRackApplicationFactory.new
@@ -661,7 +661,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
       allow(app).to receive(:init) do
-        sleep(0.10)
+        sleep(0.05)
       end
       app
     end
@@ -675,6 +675,7 @@ def createRackServletWrapper(runtime, rackup, filename)
 
   it "throws an exception from getApplication when an app failed to initialize " +
      "(even when only a single application initialization fails)" do
+    app_init_secs = 0.05
     allow(@factory).to receive(:init)
     app_count = java.util.concurrent.atomic.AtomicInteger.new(0)
     allow(@factory).to receive(:newApplication) do
@@ -683,7 +684,7 @@ def createRackServletWrapper(runtime, rackup, filename)
         if app_count.addAndGet(1) == 2
           raise org.jruby.rack.RackInitializationException.new('failed app init')
         end
-        sleep(0.05)
+        sleep(app_init_secs)
       end
       app
     end
@@ -697,7 +698,7 @@ def createRackServletWrapper(runtime, rackup, filename)
     rescue org.jruby.rack.RackInitializationException
       # ignore - sometimes initialization happens fast enough that the init error is thrown already
     end
-    sleep(0.20)
+    sleep(num_runtimes * app_init_secs + 0.07) # sleep with a buffer
 
     failed = 0
     num_runtimes.times do
@@ -713,28 +714,29 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "wait until pool is filled when invoking getApplication (with wait set to false)" do
+    app_init_millis = 200
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
-      allow(app).to receive(:init) { sleep(0.2) }
+      allow(app).to receive(:init) { sleep(app_init_millis.to_f / 1000) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
     expect(@rack_config).to receive(:getInitialRuntimes).and_return 3
     expect(@rack_config).to receive(:getMaximumRuntimes).and_return 4
 
     @pooling_factory.init(@rack_context)
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect(@pooling_factory.getApplication).not_to be nil
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 150 # getApplication waited ~ 0.2 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(app_init_millis) # getApplication waited ~ sleep time
   end
 
   it "waits acquire timeout till an application is available from the pool (than raises)" do
+    app_init_millis = 200
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
       app = double "app"
-      expect(app).to receive(:init) { sleep(0.2) }
+      expect(app).to receive(:init) { sleep(app_init_millis.to_f / 1000) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
@@ -743,54 +745,53 @@ def createRackServletWrapper(runtime, rackup, filename)
 
     @pooling_factory.init(@rack_context)
     @pooling_factory.acquire_timeout = 1.to_java # second
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect(@pooling_factory.getApplication).not_to be nil
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 150 # getApplication waited ~ 0.2 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(app_init_millis)
 
     app2 = @pooling_factory.getApplication # now the pool is empty
-
-    @pooling_factory.acquire_timeout = 0.1.to_java # second
-    millis = java.lang.System.currentTimeMillis
+    timeout_millis = 100
+    @pooling_factory.acquire_timeout = (timeout_millis.to_f / 1000).to_java
+    start = java.lang.System.currentTimeMillis
     expect { @pooling_factory.getApplication }.to raise_error(org.jruby.rack.AcquireTimeoutException)
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 90 # waited about ~ 0.1 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(20).of(timeout_millis)
 
     @pooling_factory.finishedWithApplication(app2) # gets back to the pool
     expect(@pooling_factory.getApplication).to eq app2
   end
 
   it "gets and initializes new applications until maximum allows to create more" do
+    app_init_millis = 100
     allow(@factory).to receive(:init)
     expect(@factory).to receive(:newApplication).twice do
       app = double "app (new)"
-      expect(app).to receive(:init) { sleep(0.1) }
+      expect(app).to receive(:init) { sleep(app_init_millis.to_f / 1000) }
       app
     end
     allow(@rack_config).to receive(:getBooleanProperty).with("jruby.runtime.init.wait").and_return false
     allow(@rack_config).to receive(:getInitialRuntimes).and_return 2
     allow(@rack_config).to receive(:getMaximumRuntimes).and_return 4
 
+    timeout_millis = 100
     @pooling_factory.init(@rack_context)
-    @pooling_factory.acquire_timeout = 0.10.to_java # second
+    @pooling_factory.acquire_timeout = (timeout_millis.to_f / 1000).to_java # second
 
     2.times { expect(@pooling_factory.getApplication).not_to be nil }
 
+    app_get_millis = 150
     expect(@factory).to receive(:getApplication).twice do
-      app = double "app (get)"; sleep(0.15); app
+      app = double "app (get)"; sleep(app_get_millis.to_f / 1000); app
     end
 
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     2.times { expect(@pooling_factory.getApplication).not_to be nil }
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 300 # waited about 2 x 0.15 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(70).of(2 * app_get_millis)
 
-    millis = java.lang.System.currentTimeMillis
+    start = java.lang.System.currentTimeMillis
     expect {
       @pooling_factory.getApplication
     }.to raise_error(org.jruby.rack.AcquireTimeoutException)
-    millis = java.lang.System.currentTimeMillis - millis
-    expect(millis).to be >= 90 # waited about ~ 0.10 secs
+    expect(java.lang.System.currentTimeMillis - start).to be_within(20).of(timeout_millis)
   end
 
   it "initializes initial runtimes in paralel (with wait set to false)" do
@@ -817,12 +818,11 @@ def createRackServletWrapper(runtime, rackup, filename)
   end
 
   it "throws from init when application initialization in thread failed" do
+    app_init_secs = 0.05
     allow(@factory).to receive(:init)
     allow(@factory).to receive(:newApplication) do
       app = double "app"
-      allow(app).to receive(:init) do
-        sleep(0.05); raise "app.init raising"
-      end
+      allow(app).to receive(:init) { sleep(app_init_secs); raise "app.init raising" }
       app
     end
     allow(@rack_config).to receive(:getInitialRuntimes).and_return 2
@@ -841,9 +841,6 @@ def createRackServletWrapper(runtime, rackup, filename)
 
     expect { @pooling_factory.init(@rack_context) }.to raise_error org.jruby.rack.RackInitializationException
     expect(raise_error_logged).to eql 1 # logs same init exception once
-
-    # NOTE: seems it's not such a good idea to return empty on init error
-    #     expect(@pooling_factory.getManagedApplications).to be_empty
   end
 
 end

src/spec/ruby/spec_helper.rb

@@ -10,6 +10,7 @@
 
 java_import 'org.jruby.rack.RackApplicationFactory'
 java_import 'org.jruby.rack.DefaultRackApplicationFactory'
+java_import 'org.jruby.rack.rails.RailsRackApplicationFactory'
 java_import 'org.jruby.rack.servlet.RequestCapture'
 java_import 'org.jruby.rack.servlet.ResponseCapture'
 java_import 'org.jruby.rack.servlet.RewindableInputStream'