#235 Support for kotlin.time.Duration in Kotlin DSL (#285)

bedla · web-flow · commit 6a35c247c324 · 2025-02-14T15:06:51.000+01:00
diff --git a/awaitility-kotlin/src/main/kotlin/org/awaitility/kotlin/AwaitilityKt.kt b/awaitility-kotlin/src/main/kotlin/org/awaitility/kotlin/AwaitilityKt.kt
@@ -17,6 +17,7 @@ import java.time.Duration
 import java.util.concurrent.ExecutorService
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.reflect.KClass
+import kotlin.time.toJavaDuration
 
 /**
  * This is typically the starting point of the Kotlin "DSL". Allows you to write `await` instead of `await()`. For example:
@@ -164,6 +165,15 @@ infix fun ConditionFactory.untilAsserted(fn: () -> Unit): Unit = untilAsserted(f
  */
 infix fun ConditionFactory.atMost(duration: Duration): ConditionFactory = atMost(duration)
 
+/**
+ * Await at most `timeout` before throwing a timeout exception.
+ *
+ * @param duration the duration
+ * @return the condition factory
+ * @since 4.2.3
+ */
+infix fun ConditionFactory.atMost(duration: kotlin.time.Duration): ConditionFactory = atMost(duration.toJavaDuration())
+
 /**
  * Condition has to be evaluated not earlier than `timeout` before throwing a timeout exception.
  *
@@ -173,6 +183,15 @@ infix fun ConditionFactory.atMost(duration: Duration): ConditionFactory = atMost
  */
 infix fun ConditionFactory.atLeast(timeout: Duration): ConditionFactory = atLeast(timeout)
 
+/**
+ * Condition has to be evaluated not earlier than `timeout` before throwing a timeout exception.
+ *
+ * @param timeout the timeout
+ * @return the condition factory
+ * @since 4.2.3
+ */
+infix fun ConditionFactory.atLeast(timeout: kotlin.time.Duration): ConditionFactory = atLeast(timeout.toJavaDuration())
+
 /**
  * Await forever until the condition is satisfied. Caution: You can block
  * subsequent tests and the entire build can hang indefinitely, it's
@@ -249,6 +268,17 @@ infix fun ConditionFactory.withAlias(alias: String): ConditionFactory = alias(al
  */
 infix fun ConditionFactory.withPollDelay(pollDelay: Duration): ConditionFactory = pollDelay(pollDelay)
 
+/**
+ * Specify the delay that will be used before Awaitility starts polling for
+ * the result the first time. If you don't specify a poll delay explicitly
+ * it'll be the same as the poll interval.
+ *
+ * @param pollDelay the poll delay
+ * @return the condition factory
+ * @since 4.2.3
+ */
+infix fun ConditionFactory.withPollDelay(pollDelay: kotlin.time.Duration): ConditionFactory = withPollDelay(pollDelay.toJavaDuration())
+
 /**
  * Specify the polling interval Awaitility will use for this await
  * statement. This means the frequency in which the condition is checked for
@@ -261,6 +291,18 @@ infix fun ConditionFactory.withPollDelay(pollDelay: Duration): ConditionFactory
  */
 infix fun ConditionFactory.withPollInterval(pollInterval: Duration): ConditionFactory = pollInterval(pollInterval)
 
+/**
+ * Specify the polling interval Awaitility will use for this await
+ * statement. This means the frequency in which the condition is checked for
+ * completion.
+ *
+ * @param pollInterval the poll interval
+ * @return the condition factory
+ * @since 4.2.3
+ * @see [ConditionFactory.pollInterval]
+ */
+infix fun ConditionFactory.withPollInterval(pollInterval: kotlin.time.Duration): ConditionFactory = withPollInterval(pollInterval.toJavaDuration())
+
 /**
  * Specify the polling interval Awaitility will use for this await
  * statement. For example [org.awaitility.pollinterval.FibonacciPollInterval.fibonacci].
@@ -371,4 +413,22 @@ infix fun <T> ConditionFactory.conditionEvaluationListener(conditionEvaluationLi
  * @return the condition factory
  * @since 4.2.1
  */
-infix fun ConditionFactory.logging(logPrinter: (String) -> Unit) = logging(logPrinter)
+infix fun ConditionFactory.logging(logPrinter: (String) -> Unit) = logging(logPrinter)
+
+/**
+ * Await at the predicate holds during at least <code>timeout</code>
+ *
+ * @param timeout the timeout
+ * @return the condition factory
+ * @since 4.2.3
+ */
+infix fun ConditionFactory.during(duration: Duration): ConditionFactory = during(duration)
+
+/**
+ * Await at the predicate holds during at least <code>timeout</code>
+ *
+ * @param timeout the timeout
+ * @return the condition factory
+ * @since 4.2.3
+ */
+infix fun ConditionFactory.during(duration: kotlin.time.Duration): ConditionFactory = during(duration.toJavaDuration())
diff --git a/awaitility-kotlin/src/test/kotlin/org/awaitility/kotlin/KotlinTest.kt b/awaitility-kotlin/src/test/kotlin/org/awaitility/kotlin/KotlinTest.kt
@@ -35,6 +35,11 @@ import org.junit.rules.ExpectedException
 import java.time.Duration
 import java.util.concurrent.TimeUnit.MILLISECONDS
 import java.util.concurrent.TimeUnit.SECONDS
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.system.measureTimeMillis
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
 
 class KotlinTest {
 
@@ -125,7 +130,7 @@ class KotlinTest {
     fun untilAssertedWithConditionEvaluationListener() {
         var value = false
         Asynch(fakeRepository).perform()
-    
+
         await withPollInterval ONE_HUNDRED_MILLISECONDS ignoreException IllegalArgumentException::class conditionEvaluationListener ConditionEvaluationListener<Unit> { value = true } untilAsserted {
             assertThat(fakeRepository.value).isEqualTo(1)
         }
@@ -182,6 +187,56 @@ class KotlinTest {
         }
         assertThat(data.state).isEqualTo("After")
     }
+
+    @Test
+    fun atMostWithKotlinDuration() {
+        await() atMost 1.seconds untilNull { null }
+    }
+
+    @Test
+    fun atLeastWithKotlinDuration() {
+        await() atLeast 1.seconds untilNull {
+            Thread.sleep((1.seconds + 500.milliseconds).inWholeMilliseconds)
+            null
+        }
+    }
+
+    @Test
+    fun withPollDelayAndWithPollIntervalWithKotlinDuration() {
+        val ref = AtomicReference("value")
+
+        Thread() {
+            Thread.sleep((1.seconds + 500.milliseconds).inWholeMilliseconds)
+            ref.set(null)
+        }.start()
+
+        val count = AtomicInteger()
+        await() withPollDelay 1.seconds withPollInterval 100.milliseconds untilNull {
+            count.incrementAndGet()
+            ref.get()
+        }
+        // Mathematically we have 100ms in 500ms 5 times,
+        // invocation count should be 5 times -> safe assertion interval of invocation is [4, 6] times
+        assertThat(count).hasValueBetween(4, 6)
+    }
+
+    @Test(timeout = 2000)
+    fun awaitDuringTimeOnCondition() {
+        val duration = measureTimeMillis {
+            await() during ONE_SECOND until { true }
+        }
+
+        assertThat(duration).isGreaterThan(1000)
+    }
+
+    @Test(timeout = 2000)
+    fun awaitDuringTimeOnConditionWithKotlinDuration() {
+        val duration = measureTimeMillis {
+            await() during 1.seconds until { true }
+        }
+
+        assertThat(duration).isGreaterThan(1000)
+    }
 }
 
 class AsynchObject<T>(private val repository: FakeGenericRepository<T>, private val changeTo: T) {
