KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

How to use Exceptions class of io.kotest.assertions package

Best Kotest code snippet using io.kotest.assertions.Exceptions

SuspendRunners.kt

Source:SuspendRunners.kt

1package arrow.fx.coroutines2import io.kotest.assertions.fail3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.matchers.shouldBe5import io.kotest.property.Arb6import io.kotest.property.arbitrary.int7import io.kotest.property.arbitrary.map8import io.kotest.property.checkAll9import kotlin.coroutines.Continuation10import kotlin.coroutines.EmptyCoroutineContext11import kotlin.coroutines.startCoroutine12class SuspendRunners : ArrowFxSpec(13  spec = {14    "should defer evaluation until run" {15      var run = false16      val fa = suspend { run = true }17      run shouldBe false18      Platform.unsafeRunSync(fa)19      run shouldBe true20    }21    "invoke is called on every run call" {22      val sideEffect = SideEffect()23      val fa = suspend { sideEffect.increment(); 1 }24      Platform.unsafeRunSync(fa)25      Platform.unsafeRunSync(fa)26      sideEffect.counter shouldBe 227    }28    "should catch exceptions within main block" {29      checkAll(Arb.throwable()) { e ->30        val task = suspend { throw e }31        shouldThrow<Throwable> {32          Platform.unsafeRunSync { task.invoke() }33        } shouldBe e34      }35    }36    "should yield immediate successful invoke value" {37      checkAll(Arb.int()) { i ->38        val task = suspend { i }39        val run = Platform.unsafeRunSync { task.invoke() }40        run shouldBe i41      }42    }43    "should return a null value from unsafeRunSync" {44      val run = Platform.unsafeRunSync { suspend { null }() }45      run shouldBe null46    }47    "suspend with unsafeRunSync" {48      checkAll(Arb.int().map { suspend { it } }) { i ->49        val map = suspend { i() + 1 }50        Platform.unsafeRunSync(map) shouldBe (i.invoke() + 1)51      }52    }53    "should complete when running a pure value with unsafeRunAsync" {54      checkAll(Arb.int()) { i ->55        val task = suspend { i }56        task.startCoroutine(57          Continuation(EmptyCoroutineContext) { res ->58            res.getOrThrow() shouldBe i59          }60        )61      }62    }63    "should return an error when running an exception with unsafeRunAsync" {64      checkAll(Arb.throwable()) { e ->65        val task = suspend { throw e }66        task.startCoroutine(67          Continuation(EmptyCoroutineContext) { res ->68            res.fold(69              { fail("Expected $e but found with $it") },70              {71                it shouldBe e72              }73            )74          }75        )76      }77    }78    "should rethrow exceptions within run block with unsafeRunAsync" {79      checkAll(Arb.throwable()) { e ->80        val task = suspend { throw e }81        try {82          task.startCoroutine(83            Continuation(EmptyCoroutineContext) { res ->84              res.fold({ fail("Expected $e but found with $it") }, { throw e })85            }86          )87          fail("Should rethrow the exception")88        } catch (t: Throwable) {89          t shouldBe e90        }91      }92    }93    "should complete when running a pure value with startCoroutineCancellable" {94      checkAll(Arb.int()) { i ->95        val task = suspend { i }96        task.startCoroutineCancellable(97          CancellableContinuation(EmptyCoroutineContext) { res ->98            res.getOrThrow() shouldBe i99          }100        )101      }102    }103    "should return exceptions within main block with startCoroutineCancellable" {104      checkAll(Arb.throwable()) { e ->105        val task = suspend { throw e }106        task.startCoroutineCancellable(107          CancellableContinuation(EmptyCoroutineContext) { res ->108            res.fold({ fail("Expected $e but found with $it") }, { it shouldBe e })109          }110        )111      }112    }113    "should rethrow exceptions within run block with startCoroutineCancellable" {114      checkAll(Arb.throwable()) { e ->115        val task = suspend { throw e }116        try {117          task.startCoroutineCancellable(118            CancellableContinuation(EmptyCoroutineContext) { res ->119              res.fold({ fail("Expected $e but found with $it") }, { throw it })120            }121          )122          fail("Should rethrow the exception")123        } catch (t: Throwable) {124          t shouldBe e125        }126      }127    }128    "Effect-full stack-safe map" {129      val max = 10000130      suspend fun addOne(n: Int): Int = n + 1 // Equivalent of `map` for `IO`.131      suspend fun fa(): Int =132        (0 until (max * 10000)).fold(0) { acc, _ -> addOne(acc) }133      Platform.unsafeRunSync { fa() } shouldBe (max * 10000)134    }135  }136)...

SchemaServiceImplTest.kt

Source:SchemaServiceImplTest.kt

1package org.factcast.schema.registry.cli.utils2import com.fasterxml.jackson.databind.JsonNode3import com.github.fge.jsonschema.core.exceptions.ProcessingException4import com.github.fge.jsonschema.main.JsonSchema5import com.github.fge.jsonschema.main.JsonSchemaFactory6import io.kotest.assertions.arrow.core.shouldBeLeft7import io.kotest.assertions.arrow.core.shouldBeRight8import io.kotest.core.spec.style.StringSpec9import io.kotest.core.test.TestCase10import io.kotest.core.test.TestResult11import io.kotest.matchers.shouldBe12import io.kotest.matchers.types.shouldBeInstanceOf13import io.mockk.clearAllMocks14import io.mockk.every15import io.mockk.mockk16import io.mockk.verifyAll17import org.factcast.schema.registry.cli.fs.FileSystemService18import org.factcast.schema.registry.cli.validation.ProjectError19import java.nio.file.Paths20class SchemaServiceImplTest : StringSpec() {21    val fs = mockk<FileSystemService>()22    val jsonSchemaFactory = mockk<JsonSchemaFactory>()23    val schemaMock = mockk<JsonSchema>()24    val jsonNodeMock = mockk<JsonNode>()25    val dummyPath = Paths.get(".")26    val uut = SchemaServiceImpl(fs, jsonSchemaFactory)27    override fun afterTest(testCase: TestCase, result: TestResult) {28        clearAllMocks()29    }30    init {31        "loadSchema for invalid path" {32            every { fs.readToJsonNode(dummyPath) } returns null33            uut.loadSchema(dummyPath).shouldBeLeft().also {34                it.shouldBeInstanceOf<ProjectError.NoSuchFile>()35            }36            verifyAll {37                fs.readToJsonNode(dummyPath)38            }39        }40        "loadSchema for corrupted schema" {41            every { fs.readToJsonNode(dummyPath) } returns jsonNodeMock42            every { jsonSchemaFactory.getJsonSchema(any<JsonNode>()) } throws ProcessingException("")43            uut.loadSchema(dummyPath).shouldBeLeft().also {44                it.shouldBeInstanceOf<ProjectError.CorruptedSchema>()45            }46            verifyAll {47                fs.readToJsonNode(dummyPath)48                jsonSchemaFactory.getJsonSchema(any<JsonNode>())49            }50        }51        "loadSchema for valid schema" {52            every { fs.readToJsonNode(dummyPath) } returns jsonNodeMock53            every { jsonSchemaFactory.getJsonSchema(any<JsonNode>()) } returns schemaMock54            uut.loadSchema(dummyPath).shouldBeRight().also {55                it shouldBe schemaMock56            }57            verifyAll {58                fs.readToJsonNode(dummyPath)59                jsonSchemaFactory.getJsonSchema(any<JsonNode>())60            }61        }62    }63}...

PetWeightTest.kt

Source:PetWeightTest.kt

1package app.civa.vaccination.domain2import io.kotest.assertions.throwables.shouldNotThrowAny3import io.kotest.assertions.throwables.shouldThrowExactly4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.data.blocking.forAll6import io.kotest.data.row7import io.kotest.matchers.shouldBe8import io.kotest.matchers.throwable.shouldHaveMessage9import io.kotest.matchers.types.shouldBeInstanceOf10class PetWeightTest : BehaviorSpec({11    given("positive numbers or zero as inputs") {12        `when`("PetWeight is instantiated") {13            then("it should not throw any exceptions") {14                forAll(15                    row(0.56),16                    row(2.56),17                    row(5.5),18                    row(8.7123189),19                    row(10.051)20                ) {21                    shouldNotThrowAny {22                        PetWeight from it23                    }24                }25            }26        }27    }28    given("negative numbers or zero as inputs") {29        `when`("PetWeight is instantiated") {30            then("it should throw InvalidPetWeightException") {31                forAll(32                    row(0.0),33                    row(-2.56),34                    row(-9995.5),35                ) {36                    val exception = shouldThrowExactly<InvalidPetWeightException> {37                        PetWeight from it38                    }39                    exception shouldHaveMessage "Pet weight must be positive: 0 (ZERO) or greater"40                    exception.explain() shouldBe "Expected: $it to be bigger than 0.0, Actual: $it"41                }42            }43        }44    }45    given("a value that does not need rounding") {46        `when`("property value is accessed") {47            then("it should return correct information") {48                (PetWeight from 5.78)49                    .shouldBeInstanceOf<PetWeight>()50                    .value shouldBe 5.7851            }52        }53    }54    given("a value that needs rounding") {55        `when`("value is closer to ceil") {56            then("it should round up") {57                (PetWeight from 2.678)58                    .shouldBeInstanceOf<PetWeight>()59                    .value shouldBe 2.6860            }61        }62        `when`("value is closer to floor") {63            then("it should round down") {64                (PetWeight from 2.674)65                    .shouldBeInstanceOf<PetWeight>()66                    .value shouldBe 2.6767            }68        }69    }70})...

build.gradle.kts

Source:build.gradle.kts

...48   // configure kotest to run49   tasks.test {50      useJUnitPlatform()51      testLogging {52         showExceptions = true53         showStandardStreams = true54         exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL55      }56   }57   // set all projects to latest LTS of the JDK and stable kotlin version58   tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {59      kotlinOptions.jvmTarget = "17"60      kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlin.time.ExperimentalTime"61   }62}...

AdminAuthConfigTest.kt

Source:AdminAuthConfigTest.kt

1package com.kuvaszuptime.kuvasz.config2import io.kotest.assertions.exceptionToMessage3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.matchers.string.shouldContain6import io.micronaut.context.ApplicationContext7import io.micronaut.context.env.PropertySource8import io.micronaut.context.exceptions.BeanInstantiationException9class AdminAuthConfigTest : BehaviorSpec(10    {11        given("an AdminAuthConfig bean") {12            `when`("password is less than 12 characters long") {13                val properties = PropertySource.of(14                    "test",15                    mapOf(16                        "admin-auth.username" to "test-user",17                        "admin-auth.password" to "tooShortPas"18                    )19                )20                then("ApplicationContext should throw a BeanInstantiationException") {21                    val exception = shouldThrow<BeanInstantiationException> {22                        ApplicationContext.run(properties)23                    }24                    exceptionToMessage(exception) shouldContain "password - size must be between 12"25                }26            }27            `when`("username or password is blank") {28                val properties = PropertySource.of(29                    "test",30                    mapOf(31                        "admin-auth.username" to "",32                        "admin-auth.password" to ""33                    )34                )35                then("ApplicationContext should throw a BeanInstantiationException") {36                    val exception = shouldThrow<BeanInstantiationException> {37                        ApplicationContext.run(properties)38                    }39                    exceptionToMessage(exception) shouldContain "username - must not be blank"40                    exceptionToMessage(exception) shouldContain "password - must not be blank"41                }42            }43        }44    }45)...

AppConfigTest.kt

Source:AppConfigTest.kt

1package com.kuvaszuptime.kuvasz.config2import io.kotest.assertions.exceptionToMessage3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.matchers.string.shouldContain6import io.micronaut.context.ApplicationContext7import io.micronaut.context.env.PropertySource8import io.micronaut.context.exceptions.BeanInstantiationException9class AppConfigTest : BehaviorSpec(10    {11        given("an AppConfig bean") {12            `when`("there is a data-retention-days parameter with a null value") {13                val properties = PropertySource.of(14                    "test",15                    mapOf(16                        "app-config.data-retention-days" to "null"17                    )18                )19                then("ApplicationContext should throw a BeanInstantiationException") {20                    val exception = shouldThrow<BeanInstantiationException> {21                        ApplicationContext.run(properties)22                    }23                    exceptionToMessage(exception) shouldContain24                        "Error resolving property value [app-config.data-retention-days]"25                }26            }27            `when`("there is a data-retention-days parameter with an exceptionally low value") {28                val properties = PropertySource.of(29                    "test",30                    mapOf(31                        "app-config.data-retention-days" to "6"32                    )33                )34                then("ApplicationContext should throw a BeanInstantiationException") {35                    val exception = shouldThrow<BeanInstantiationException> {36                        ApplicationContext.run(properties)37                    }38                    exceptionToMessage(exception) shouldContain "dataRetentionDays - must be greater than or equal to 7"39                }40            }41        }42    }43)...

BatchTest.kt

Source:BatchTest.kt

1package app.civa.vaccination.domain2import io.kotest.assertions.throwables.shouldNotThrowAny3import io.kotest.assertions.throwables.shouldThrowExactly4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.data.blocking.forAll6import io.kotest.data.row7import io.kotest.matchers.shouldBe8import io.kotest.matchers.throwable.shouldHaveMessage9import io.kotest.matchers.types.shouldBeInstanceOf10class BatchTest : BehaviorSpec({11    given("valid inputs") {12        `when`("Batch is instantiated") {13            then("it should not throw any exceptions") {14                forAll(15                        row("000/00"),16                        row("086/21"),17                        row("999/99")18                ) { shouldNotThrowAny { Batch from it } }19            }20        }21    }22    given("invalid inputs") {23        `when`("Batch is instantiated") {24            then("it should throw InvalidBatchException") {25                forAll(26                        row("1231232"),27                        row("99/999"),28                        row("/"),29                        row("1234/12")30                ) {31                    val exception = shouldThrowExactly<InvalidBatchException> {32                        Batch from it33                    }34                    exception shouldHaveMessage "Batch doesn't match required pattern"35                    exception.explain() shouldBe "Expected: ddd/dd, Actual: $it"36                }37            }38        }39    }40    given("a valid Batch instance") {41        `when`("property value is accessed") {42            then("it should return correct information") {43                (Batch from "002/21")44                        .shouldBeInstanceOf<Batch>()45                        .value shouldBe "002/21"46            }47        }48    }49})...

SMTPMailerConfigTest.kt

Source:SMTPMailerConfigTest.kt

1package com.kuvaszuptime.kuvasz.config2import io.kotest.assertions.exceptionToMessage3import io.kotest.assertions.throwables.shouldThrow4import io.kotest.core.spec.style.BehaviorSpec5import io.kotest.matchers.string.shouldContain6import io.micronaut.context.ApplicationContext7import io.micronaut.context.env.PropertySource8import io.micronaut.context.exceptions.BeanInstantiationException9class SMTPMailerConfigTest : BehaviorSpec(10    {11        given("an SMTPMailerConfig bean") {12            `when`("the SMTP host does not exists") {13                val properties = PropertySource.of(14                    "test",15                    mapOf(16                        "handler-config.smtp-event-handler.enabled" to "true",17                        "smtp-config.host" to "localhost",18                        "smtp-config.port" to "123"19                    )20                )21                then("ApplicationContext should throw a BeanInstantiationException") {22                    val exception = shouldThrow<BeanInstantiationException> {23                        ApplicationContext.run(properties)24                    }25                    exceptionToMessage(exception) shouldContain "Error when trying to open connection to the server"26                }27            }28        }29    }30)...

Exceptions

Using AI Code Generation

1val result = try { 1 / 0 } catch (e: ArithmeticException) { e }2val result = try { 1 / 0 } catch (e: ArithmeticException) { e }3val result = try { 1 / 0 } catch (e: ArithmeticException) { e }4val result = try { 1 / 0 } catch (e: ArithmeticException) { e }5val result = try { 1 / 0 } catch (e: ArithmeticException) { e }6val result = try { 1 / 0 } catch (e: ArithmeticException) { e }7val result = try { 1 / 0 } catch (e: ArithmeticException) { e }8val result = try { 1 / 0 } catch (e: ArithmeticException) { e }9val result = try { 1 / 0 } catch (e: ArithmeticException) { e }10val result = try { 1 / 0 } catch (e: ArithmeticException) { e }11val result = try { 1 / 0 } catch (e: ArithmeticException) { e }12val result = try {

Exceptions

Using AI Code Generation

1result shouldBeFailure { it.message shouldBe "some error message" }2result shouldBeFailure { it.message shouldBe "some error message" }3result shouldBeFailure { it.message shouldBe "some error message" }4result shouldBeFailure { it.message shouldBe "some error message" }5result shouldBeFailure { it.message shouldBe "some error message" }6result shouldBeFailure { it.message shouldBe "some error message" }7result shouldBeFailure { it.message shouldBe "some error message" }8result shouldBeFailure { it.message shouldBe "some error message" }9result shouldBeFailure { it.message shouldBe "some error message" }10result shouldBeFailure { it.message shouldBe "some error message" }11result shouldBeFailure { it.message shouldBe "some error message" }12result shouldBeFailure { it.message shouldBe "some error message" }

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.