How to use Interval class of io.kotest.assertions.until package

1package org.learning.demo.app.consumer2import io.kotest.assertions.timing.EventuallyConfig3import io.kotest.assertions.timing.continually4import io.kotest.assertions.timing.eventually5import io.kotest.assertions.until.FixedInterval6import io.kotest.assertions.until.fixed7import io.kotest.matchers.shouldBe8import kotlinx.coroutines.runBlocking9import org.junit.jupiter.api.BeforeEach10import org.junit.jupiter.api.Test11import org.learning.demo.IntegrationTest12import org.learning.demo.app.repository.InventoryProduct13import org.learning.demo.app.repository.ProductRepository14import org.learning.demo.lib.kafka.KafkaMessage15import org.learning.demo.lib.kafka.producer.KafkaProducer16import org.learning.demo.lib.kafka.repository.ProcessedMessageAudit17import org.learning.demo.lib.kafka.repository.ProcessedMessageAuditRepository18import org.learning.demo.util.assertNextWith19import org.springframework.beans.factory.annotation.Autowired20import java.time.LocalDateTime21import kotlin.time.Duration.Companion.seconds22import kotlin.time.DurationUnit23import kotlin.time.toDuration24@IntegrationTest25class InventoryConsumerTest(26    @Autowired private val kafkaProducer: KafkaProducer,27    @Autowired private val productRepository: ProductRepository,28    @Autowired private val processedMessageAuditRepository: ProcessedMessageAuditRepository,29) {30    @BeforeEach31    fun setUp() {32        processedMessageAuditRepository.deleteAll().block()33    }34    @Test35    fun `should update count of remain products on consuming order created event`() {36        productRepository.saveAll(37            listOf(38                InventoryProduct("P-001", 20),39                InventoryProduct("P-002", 12),40                InventoryProduct("P-003", 12),41            )42        ).blockLast()43        kafkaProducer.produce(44            "order",45            KafkaMessage(46                eventId = "ev-00-11",47                eventName = "order-created",48                createdTime = "2020-01-01",49                partitionKey = "123",50                identifiers = mapOf(),51                payload = mapOf(52                    "orderId" to "001",53                    "totalPrice" to 234.56,54                    "products" to setOf(55                        mapOf(56                            "productCode" to "P-001",57                            "quantity" to 12,58                            "price" to 345.3259                        ),60                        mapOf(61                            "productCode" to "P-002",62                            "quantity" to 12,63                            "price" to 345.3264                        ),65                    )66                )67            )68        ).block()69        runBlocking {70            eventually(71                EventuallyConfig(72                    duration = 5.toDuration(DurationUnit.SECONDS),73                    interval = FixedInterval(100.toDuration(DurationUnit.MILLISECONDS))74                )75            ) {76                assertNextWith(productRepository.findByProductCode("P-001")) {77                    it.remainingQuantity shouldBe 878                }79                assertNextWith(productRepository.findByProductCode("P-002")) {80                    it.remainingQuantity shouldBe 081                }82                assertNextWith(productRepository.findByProductCode("P-003")) {83                    it.remainingQuantity shouldBe 1284                }85            }86        }87    }...

1package org.learning.demo.lib.kafka.consumer2import io.kotest.assertions.timing.EventuallyConfig3import io.kotest.assertions.timing.eventually4import io.kotest.assertions.until.FixedInterval5import io.kotest.matchers.collections.shouldContainExactlyInAnyOrder6import io.kotest.matchers.collections.shouldHaveSize7import kotlinx.coroutines.runBlocking8import org.junit.jupiter.api.BeforeEach9import org.junit.jupiter.api.Test10import org.learning.demo.IntegrationTest11import org.learning.demo.lib.kafka.KafkaMessage12import org.learning.demo.lib.kafka.producer.KafkaProducer13import org.learning.demo.lib.kafka.repository.ProcessedMessageAudit14import org.learning.demo.lib.kafka.repository.ProcessedMessageAuditRepository15import org.learning.demo.util.assertNextWith16import org.springframework.beans.factory.annotation.Autowired17import java.time.LocalDateTime18import kotlin.time.DurationUnit19import kotlin.time.toDuration20@IntegrationTest21class KafkaConsumerTest(22    @Autowired private val kafkaProducer: KafkaProducer,23    @Autowired private val dummyKafkaConsumer: DummyKafkaConsumer,24    @Autowired private val processedMessageAuditRepository: ProcessedMessageAuditRepository,25) {26    @BeforeEach27    fun setUp() {28        processedMessageAuditRepository.deleteAll().block()29    }30    private val message = KafkaMessage(31        eventId = "EB-001",32        eventName = "consumer-event",33        createdTime = "2020-01-01",34        partitionKey = "12",35        identifiers = mapOf(36            "key1" to "val1"37        ),38        payload = mapOf(39            "message" to "hello"40        )41    )42    @Test43    fun `should consume new message only`() {44        processedMessageAuditRepository.save(45            ProcessedMessageAudit(46                eventId = "EB-000",47                processedAt = LocalDateTime.now(),48                consumerGroupId = "kafka-tryout-consumer-group"49            )50        ).block()51        kafkaProducer52            .produce(topic = "integration-test", message = message)53            .flatMap {54                kafkaProducer.produce(topic = "integration-test-v2", message.copy(eventId = "EB-000"))55            }56            .flatMap {57                kafkaProducer.produce(topic = "integration-test-v2", message.copy(eventId = "EB-002"))58            }59            .block()60        runBlocking {61            eventually(62                EventuallyConfig(63                    duration = 10.toDuration(DurationUnit.SECONDS),64                    interval = FixedInterval(1.toDuration(DurationUnit.SECONDS))65                )66            ) {67                val messages = dummyKafkaConsumer.getAllMessages()68                messages shouldHaveSize 269                messages shouldContainExactlyInAnyOrder listOf(70                    Triple("integration-test", emptyMap(), message),71                    Triple("integration-test-v2", emptyMap(), message.copy(eventId = "EB-002")),72                )73            }74        }75    }76    @Test77    fun `should save audit of processed message`() {78        processedMessageAuditRepository.save(79            ProcessedMessageAudit(80                eventId = "EB-000",81                processedAt = LocalDateTime.now(),82                consumerGroupId = "kafka-tryout-consumer-group"83            )84        ).block()85        kafkaProducer86            .produce(topic = "integration-test", message = message)87            .flatMap {88                kafkaProducer.produce(topic = "integration-test-v2", message.copy(eventId = "EB-002"))89            }90            .block()91        runBlocking {92            eventually(93                EventuallyConfig(94                    duration = 10.toDuration(DurationUnit.SECONDS),95                    interval = FixedInterval(1.toDuration(DurationUnit.SECONDS))96                )97            ) {98                assertNextWith(processedMessageAuditRepository.findAll().collectList()) {99                    it.map { r -> r.eventId } shouldContainExactlyInAnyOrder listOf("EB-000", "EB-001", "EB-002")100                }101            }102        }103    }104}...

1package io.alienhead.kronik.core2import io.kotest.assertions.fail3import io.kotest.assertions.until.fixed4import io.kotest.assertions.until.until5import io.kotest.assertions.withClue6import io.kotest.core.spec.style.DescribeSpec7import io.kotest.matchers.shouldBe8import kotlinx.coroutines.delay9import kotlinx.coroutines.launch10import kotlin.time.Duration11import kotlin.time.ExperimentalTime12@ExperimentalTime13class TimedCoroutinesTests : DescribeSpec({14  describe("TimedCoroutines") {15    describe("delayedLaunch()") {16      it("delays the launch of a coroutine") {17        var toTest = 118        launch {19          delayedLaunch(500) {20            toTest++21          }22        }23        withClue("delays for 500 ms") {24          until(Duration.Companion.milliseconds(300), Duration.milliseconds(100).fixed()) {25            toTest == 126          }27        }28        withClue("updates toTest after 500 ms") {29          until(Duration.Companion.milliseconds(600), Duration.milliseconds(100).fixed()) {30            toTest == 231          }32        }33      }34      it("cancels if max time value") {35        var toTest = 136        val testJob = launch {37          delayedLaunch(Long.MAX_VALUE) {38            toTest++39          }40        }41        delay(100)42        if (!testJob.isCompleted) {43          testJob.cancel()44          testJob.join()45          fail("The coroutine should have cancelled.")46        }47        toTest shouldBe 148      }49    }50    describe("intervalLaunchUntil()") {51      it("delays the launch of a coroutine") {52        var toTest = 153        launch {54          intervalLaunchUntil(500, intervalMillis = 500, 2) {55            toTest++56          }57        }58        withClue("delays for 500 ms") {59          until(Duration.Companion.milliseconds(300), Duration.milliseconds(100).fixed()) {60            toTest == 161          }62        }63        withClue("updates toTest after 500 ms") {64          until(Duration.Companion.milliseconds(600), Duration.milliseconds(100).fixed()) {65            toTest == 266          }67        }68        withClue("runs block again after another 150 ms") {69          until(Duration.Companion.milliseconds(1100), Duration.milliseconds(100).fixed()) {70            toTest == 371          }72        }73      }74      it("cancels if initial delay is the max value") {75        var toTest = 176        val testJob = launch {77          intervalLaunchUntil(Long.MAX_VALUE, intervalMillis = 500, 1) {78            toTest++79          }80        }81        delay(100)82        if (!testJob.isCompleted) {83          testJob.cancel()84          testJob.join()85          fail("The coroutine should have cancelled.")86        }87        toTest shouldBe 188      }89      it("cancels if interval delay is the max value") {90        var toTest = 191        val testJob = launch {92          intervalLaunchUntil(500, intervalMillis = Long.MAX_VALUE, 1) {93            toTest++94          }95        }96        delay(100)97        if (!testJob.isCompleted) {98          testJob.cancel()99          testJob.join()100          fail("The coroutine should have cancelled.")101        }102        toTest shouldBe 1103      }104    }105  }106})...

1package com.sksamuel.kotest.assertions.until2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.assertions.until.PatienceConfig4import io.kotest.assertions.until.fibonacci5import io.kotest.assertions.until.fixed6import io.kotest.assertions.until.until7import io.kotest.core.spec.style.FunSpec8import io.kotest.matchers.comparables.shouldBeGreaterThan9import io.kotest.matchers.comparables.shouldBeLessThan10import io.kotest.matchers.shouldBe11import java.util.concurrent.CountDownLatch12import java.util.concurrent.TimeUnit13import kotlin.time.Duration.Companion.milliseconds14import kotlin.time.Duration.Companion.seconds15import kotlin.time.TimeSource16class UntilTest : FunSpec({17   test("until with immediate boolean predicate") {18      var attempts = 019       until(1.seconds) {20           attempts++21           System.currentTimeMillis() > 022       }23      attempts shouldBe 124   }25   test("until with boolean predicate that resolves before time duration") {26      var attempts = 027       until(3.seconds) {28           attempts++29           attempts == 230       }31      attempts shouldBe 232   }33   test("until with boolean predicate and interval") {34      var attempts = 035       until(2.seconds, 10.milliseconds.fixed()) {36           attempts++37           attempts == 10038       }39      attempts shouldBe 10040   }41   test("until with patience config") {42      var attempts = 043      until(PatienceConfig(2.seconds, 10.milliseconds.fixed())) {44         attempts++45         attempts == 10046      }47      attempts shouldBe 10048   }49   test("until with predicate") {50      var attempts = 051      var t = ""52       until(5.seconds, { t == "xxx" }) {53           attempts++54           t += "x"55       }56      attempts shouldBe 357   }58   test("until with predicate and interval") {59      val start = TimeSource.Monotonic.markNow()60      var attempts = 061      var t = ""62       until(1.seconds, 10.milliseconds.fixed(), { t == "xxxx" }) {63           attempts++64           t += "x"65       }66      attempts shouldBe 467      start.elapsedNow().shouldBeLessThan(100.milliseconds)68   }69   test("until with predicate, interval, and listener") {70      var t = ""71      val latch = CountDownLatch(5)72      val result =73          until(1.seconds, 10.milliseconds.fixed(), { t == "xxxxx" }, { latch.countDown() }) {74              t += "x"75              t76          }77      latch.await(15, TimeUnit.SECONDS) shouldBe true78      result shouldBe "xxxxx"79   }80   test("until should throw when the predicate doesn't equal true in the time period") {81      shouldThrow<AssertionError> {82          until(1.seconds, { it == 2 }) {83              184          }85      }86   }87   test("until should support fibonacci intervals") {88      val start = TimeSource.Monotonic.markNow()89      var t = ""90      var attempts = 091      val result = until(10.seconds, 10.milliseconds.fibonacci(), { t == "xxxxxx" }) {92          attempts++93          t += "x"94          t95      }96      attempts shouldBe 697      result shouldBe "xxxxxx"98      start.elapsedNow().inWholeMilliseconds.shouldBeGreaterThan(100)99   }100})...

1package com.sksamuel.kotest.assertions.until2import io.kotest.assertions.assertSoftly3import io.kotest.assertions.until.ExponentialInterval4import io.kotest.assertions.until.exponential5import io.kotest.core.spec.style.FunSpec6import io.kotest.matchers.comparables.shouldBeGreaterThan7import io.kotest.matchers.comparables.shouldBeGreaterThanOrEqualTo8import io.kotest.matchers.comparables.shouldBeLessThan9import io.kotest.matchers.shouldBe10import kotlin.math.pow11import kotlin.time.Duration12import kotlin.time.Duration.Companion.milliseconds13import kotlin.time.Duration.Companion.seconds14class ExponentialIntervalTest : FunSpec() {15   init {16      test("exponential interval should have a reasonable default next") {17         val identity = 2.seconds18         assertSoftly(identity.exponential()) {19            next(0) shouldBe identity * 120            next(1) shouldBe identity * 221            next(2) shouldBe identity * 422         }23         assertSoftly(identity.exponential(factor = 3.0)) {24            next(0) shouldBe identity * 125            next(1) shouldBe identity * 326            next(2) shouldBe identity * 927         }28      }29      test("exponential interval should have a reasonable default max") {30          val max = ExponentialInterval.defaultMax31          val default = 25.milliseconds.exponential()32          val unbounded = 25.milliseconds.exponential(max = null)33          val first = 034          val last = 2035          unbounded.next(first) shouldBeLessThan max36          unbounded.next(last) shouldBeGreaterThan max37          for (i in first..last) {38              val u = unbounded.next(i)39              val d = default.next(i)40              if (u < max) {41                  d shouldBe u42              } else {43                  d shouldBe max44                  u shouldBeGreaterThan max45              }46          }47      }48      test("exponential interval should respect user specified max") {49          val base = 25.milliseconds50          val n = 551          val max = base * ExponentialInterval.defaultFactor.pow(n)52          val bounded = base.exponential(max = max)53          val unbounded = base.exponential(max = null)54          val first = 055          val last = 2056          unbounded.next(first) shouldBeLessThan max57          unbounded.next(last) shouldBeGreaterThan max58          for (i in first..last) {59              val u = unbounded.next(i)60              val b = bounded.next(i)61              if (u < max) {62                  b shouldBe u63                  i shouldBeLessThan n64              } else {65                  i shouldBeGreaterThanOrEqualTo n...

1package io.kotest.assertions.timing2import io.kotest.assertions.SuspendingProducer3import io.kotest.assertions.failure4import io.kotest.assertions.until.Interval5import io.kotest.assertions.until.fixed6import kotlinx.coroutines.delay7import kotlin.time.Duration8import kotlin.time.TimeMark9import kotlin.time.TimeSource10data class ContinuallyState(val start: TimeMark, val end: TimeMark, val times: Int)11fun interface ContinuallyListener<in T> {12   fun onEval(t: T, state: ContinuallyState)13   companion object {14      val noop = ContinuallyListener<Any?> { _, _ -> }15   }16}17data class Continually<T> (18   val duration: Duration = Duration.INFINITE,19   val interval: Interval = Duration.milliseconds(25).fixed(),20   val listener: ContinuallyListener<T> = ContinuallyListener.noop,21   ) {22   suspend operator fun invoke(f: SuspendingProducer<T>): T? {23      val start = TimeSource.Monotonic.markNow()24      val end = start.plus(duration)25      var times = 026      var result: T? = null27      while (end.hasNotPassedNow()) {28         try {29            result = f()30            listener.onEval(result, ContinuallyState(start, end, times))31         } catch (e: AssertionError) {32            // if this is the first time the check was executed then just rethrow the underlying error33            if (times == 0)34               throw e35            // if not the first attempt then include how many times/for how long the test passed36            throw failure(37               "Test failed after ${start.elapsedNow()}; expected to pass for ${duration.inWholeMilliseconds}ms; attempted $times times\nUnderlying failure was: ${e.message}",38               e39            )40         }41         times++42         delay(interval.next(times))43      }44      return result45   }46}47@Deprecated("Use continually with an interval, using Duration based poll is deprecated",48   ReplaceWith("continually(duration, poll.fixed(), f = f)", "io.kotest.assertions.until.fixed")49)50suspend fun <T> continually(duration: Duration, poll: Duration, f: suspend () -> T) =51   continually(duration, poll.fixed(), f = f)52suspend fun <T> continually(duration: Duration, interval: Interval = Duration.milliseconds(10).fixed(), f: suspend () -> T) =53   Continually<T>(duration, interval).invoke(f)...

1package org.learning.demo.app.service2import io.kotest.assertions.timing.EventuallyConfig3import io.kotest.assertions.timing.eventually4import io.kotest.assertions.until.FixedInterval5import io.kotest.matchers.collections.shouldHaveSize6import io.kotest.matchers.maps.shouldContainAll7import kotlinx.coroutines.runBlocking8import org.junit.jupiter.api.BeforeEach9import org.junit.jupiter.api.Test10import org.learning.demo.IntegrationTest11import org.learning.demo.app.domain.Product12import org.learning.demo.app.view.CartView13import org.learning.demo.util.EmbeddedKafkaConsumer14import org.springframework.beans.factory.annotation.Autowired15import java.math.BigDecimal16import kotlin.time.DurationUnit17import kotlin.time.toDuration18@IntegrationTest19class OrderServiceIntegrationTest(20    @Autowired private val orderService: OrderService,21    @Autowired private val embeddedKafkaConsumer: EmbeddedKafkaConsumer22) {23    @BeforeEach24    fun setUp() {25        embeddedKafkaConsumer.clearTopic("order")26    }27    @Test28    fun `should raise order created event on order creation`() {29        val product = Product(productCode = "P-0022", quantity = 3, price = BigDecimal("20.34"))30        orderService.createOrderFrom(CartView(id = "C-002", products = setOf(product))).block()31        runBlocking {32            eventually(33                EventuallyConfig(34                    duration = 5.toDuration(DurationUnit.SECONDS),35                    interval = FixedInterval(1.toDuration(DurationUnit.SECONDS))36                )37            ) {38                val messages = embeddedKafkaConsumer.readNextMessage("order", "order-created")39                messages shouldHaveSize 140                messages.first().payload shouldContainAll mapOf(41                    "products" to listOf(42                        mapOf(43                            "productCode" to "P-0022",44                            "quantity" to 3,45                            "price" to 20.34,46                        )47                    ),48                    "totalPrice" to 61.02,49                    "eventName" to "order-created"...

1package dev.akkinoc.spring.boot.logback.access.test.assertion2import io.kotest.assertions.timing.continually3import io.kotest.assertions.timing.eventually4import io.kotest.assertions.until.fixed5import kotlinx.coroutines.runBlocking6import kotlin.time.Duration.Companion.milliseconds7import kotlin.time.Duration.Companion.seconds8/**9 * The utility methods to support test assertions.10 */11object Assertions {12    /**13     * Asserts that the assertion function will eventually pass within a short time.14     * Used to assert Logback-access events that may be appended late.15     *16     * @param T The return value type of the assertion function.17     * @param assert The assertion function that is called repeatedly.18     * @return The return value of the assertion function.19     */20    fun <T> assertLogbackAccessEventsEventually(assert: () -> T): T {21        return runBlocking {22            eventually<T>(duration = seconds(1), interval = milliseconds(100).fixed()) { assert() }23        }24    }25    /**26     * Asserts that the assertion function will continually pass within a short time.27     * Used to assert Logback-access events that may be appended late.28     *29     * @param T The return value type of the assertion function.30     * @param assert The assertion function that is called repeatedly.31     * @return The return value of the assertion function.32     */33    fun <T> assertLogbackAccessEventsContinually(assert: () -> T): T? {34        return runBlocking {35            continually(duration = seconds(1), interval = milliseconds(100).fixed()) { assert() }36        }37    }38}...