Merge pull request #7 from slu-it/wait-until-fix

Wait until operations are now guaranteed to be executed at least once

Author: slu-it

webtester-core/src/main/java/info/novatec/testit/webtester/waiting/WaitOperations.java

@@ -128,15 +128,15 @@ public static void waitUntil(long timeout, TimeUnit unit, long interval, Supplie
         boolean conditionMet = false;
         RuntimeException lastException = null;
 
-        while (!conditionMet && timeSince(start) < effectiveTimeout) {
+        do {
             try {
                 conditionMet = condition.get();
                 log.trace("condition '{}' met: {}", condition, conditionMet);
                 wait(interval, TimeUnit.MILLISECONDS);
             } catch (RuntimeException e) {
                 lastException = e;
             }
-        }
+        } while (!conditionMet && timeSince(start) < effectiveTimeout);
 
         if (!conditionMet) {
             log.debug("condition not met: {}", condition);

webtester-core/src/test/java/info/novatec/testit/webtester/waiting/WaitsTest.java renamed to webtester-core/src/test/java/info/novatec/testit/webtester/waiting/WaitOperationsTest.java

@@ -1,6 +1,7 @@
 package info.novatec.testit.webtester.waiting;
 
 import static org.mockito.Mockito.atMost;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -17,38 +18,46 @@
 
 
 @RunWith(MockitoJUnitRunner.class)
-public class WaitsTest {
+public class WaitOperationsTest {
 
     @Mock
     Supplier<Boolean> supplier;
 
     @Test
-    public void testGenericWaitUntil_GoodCase() {
-        when(supplier.get()).thenReturn(false, false, true);
-        WaitOperations.waitUntil(100, TimeUnit.MILLISECONDS, 20, supplier);
-        verify(supplier, times(3)).get();
+    public void conditionIsCheckedAtLeastOnceEvenWithoutTimeout() {
+        doReturn(true).when(supplier).get();
+        WaitOperations.waitUntil(0, TimeUnit.MILLISECONDS, 100, supplier);
+        verify(supplier, times(1)).get();
     }
 
     @Test(expected = TimeoutException.class)
-    public void testGenericWaitUntil_BadCase() {
+    public void conditionIsCheckedAtMostTimeoutDividedByIntervalTimes() {
+        doReturn(false).when(supplier).get();
         try {
-            when(supplier.get()).thenReturn(false);
             WaitOperations.waitUntil(50, TimeUnit.MILLISECONDS, 25, supplier);
         } finally {
             verify(supplier, atMost(2)).get();
         }
     }
 
     @Test
-    public void testGenericWaitUntil_OriginalExceptionAsCauseOfTimeout() {
+    public void conditionIsCheckedUntilItMatches() {
+        when(supplier.get()).thenReturn(false, false, true);
+        WaitOperations.waitUntil(100, TimeUnit.MILLISECONDS, 5, supplier);
+        verify(supplier, times(3)).get();
+    }
+
+    @Test
+    public void timeoutExceptionHasOriginalExceptionAsItsCause() {
         Throwable expected = new IllegalStateException();
         try {
             when(supplier.get()).thenThrow(expected);
-            WaitOperations.waitUntil(50, TimeUnit.MILLISECONDS, 25, supplier);
+            WaitOperations.waitUntil(0, TimeUnit.MILLISECONDS, 0, supplier);
             Assert.fail("exception not reached");
         } catch (TimeoutException e) {
             Assertions.assertThat(e.getCause()).isSameAs(expected);
         }
     }
 
+
 }