Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

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

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

all.kt

Source:all.kt

1package io.kotest.assertions2import io.kotest.common.ExperimentalKotest3import kotlinx.coroutines.withContext4import kotlin.coroutines.coroutineContext5/**6 * Runs multiple assertions and throw a composite error with all failures7 *8 * This method will run all the assertions inside [assertions] block, and will collect all failures that may happen.9 * It will then collect them into a single throwable and throw, or return the result if no assertions failed.10 *11 * ```12 *     // All assertions below are going to be executed, even when one or multiple fail.13 *     // All the failures are then collected and thrown in one single throwable.14 *     all {15 *         "foo" shouldBe "bar"16 *         "foo" shouldBe "foo17 *         "foo" shouldBe "baz"18 *     }19 * ```20 */21@ExperimentalKotest22suspend fun <T> all(assertions: suspend () -> T): T {23   if (coroutineContext[AssertionBlockContextElement] != null) { // TODO: refactor all to use errorAndAssertionsScope24      throw IllegalStateException("Assertion block functions one, any, and all are limited to a depth of 1")25   }26   // Handle the edge case of nested calls to this function by only calling throwCollectedErrors in the27   // outermost verifyAll block28   if (errorCollector.getCollectionMode() == ErrorCollectionMode.Soft) return assertions()29   errorCollector.setCollectionMode(ErrorCollectionMode.Soft)30   return try {31      withContext(AssertionBlockContextElement()) {32         assertions()33      }34   } finally {35      // In case if any exception is thrown from assertions block setting errorCollectionMode back to hard36      // so that it won't remain soft for others tests. See https://github.com/kotest/kotest/issues/193237      errorCollector.setCollectionMode(ErrorCollectionMode.Hard)38      errorCollector.throwCollectedErrors()39   }40}41inline fun <T> assertSoftly(assertions: () -> T): T {42   // Handle the edge case of nested calls to this function by only calling throwCollectedErrors in the43   // outermost verifyAll block44   if (errorCollector.getCollectionMode() == ErrorCollectionMode.Soft) return assertions()45   errorCollector.setCollectionMode(ErrorCollectionMode.Soft)46   return try {47      assertions()48   } finally {49      // In case if any exception is thrown from assertions block setting errorCollectionMode back to hard50      // so that it won't remain soft for others tests. See https://github.com/kotest/kotest/issues/193251      errorCollector.setCollectionMode(ErrorCollectionMode.Hard)52      errorCollector.throwCollectedErrors()53   }54}55/**56 * Runs multiple assertions and throw a composite error with all failures.57 *58 * This method will run all the assertions inside [assertions] block, and will collect all failures that may happen.59 * It will then collect them into a single throwable and throw, or return the result if no assertions failed.60 *61 * ```62 *     // All assertions below are going to be executed, even when one or multiple fail.63 *     // All the failures are then collected and thrown in one single throwable.64 *     assertSoftly("foo") {65 *         this[2] shouldBe 'o'66 *         length shouldBeLessThan 567 *     }68 * ```69 */70@ExperimentalKotest71suspend fun <T> all(t: T, assertions: suspend T.(T) -> Unit): T {72   return all {73      t.assertions(t)74      t75   }76}77inline fun <T> assertSoftly(t: T, assertions: T.(T) -> Unit): T {78   return assertSoftly {79      t.assertions(t)80      t81   }82}...

TreeTest.kt

Source:TreeTest.kt

1/*2 * Copyright (c) 2021. Herman Cheung3 *4 * Licensed under the Apache License, Version 2.0 (the "License");5 * you may not use this file except in compliance with the License.6 * You may obtain a copy of the License at7 *8 * http://www.apache.org/licenses/LICENSE-2.09 *10 * Unless required by applicable law or agreed to in writing, software11 * distributed under the License is distributed on an "AS IS" BASIS,12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 * See the License for the specific language governing permissions and14 * limitations under the License.15 *16 *17 */18package io.hkhc.gradle.test19import io.hkhc.utils.tree.Node20import io.hkhc.utils.tree.TreePrinter21import io.hkhc.utils.tree.toStringTree22import io.kotest.assertions.Actual23import io.kotest.assertions.Expected24import io.kotest.assertions.assertionCounter25import io.kotest.assertions.collectOrThrow26import io.kotest.assertions.eq.Eq27import io.kotest.assertions.eq.actualIsNull28import io.kotest.assertions.eq.expectedIsNull29import io.kotest.assertions.errorCollector30import io.kotest.assertions.failure31import io.kotest.assertions.show.Printed32import io.kotest.assertions.show.Show33import io.kotest.assertions.show.show34import io.kotest.matchers.Matcher35import io.kotest.matchers.should36class NodeEq<T> : Eq<Node<T>> {37    override fun equals(actual: Node<T>, expected: Node<T>): Throwable? {38        return when {39            actual === expected -> null40            actual == expected -> null41            else ->42                failure(Expected(expected.show()), Actual(actual.show()))43        }44    }45}46fun <T : Any?> eq(actual: Node<T>?, expected: Node<T>?): Throwable? {47    // if we have null and non null, usually that's a failure, but people can override equals to allow it48    println("Node<T> eq match")49    return when {50        actual === expected -> null51        actual == null && expected == null -> null52        actual == null && expected != null && actual != expected -> actualIsNull(expected)53        actual != null && expected == null && actual != expected -> expectedIsNull(actual)54        actual != null && expected != null -> NodeEq<T>().equals(actual, expected)55        else -> null56    }57}58@Suppress("UNCHECKED_CAST")59infix fun <T> Node<T>.shouldBe(expected: Node<T>) {60    println("Node shouldBe")61    when (expected) {62        is Matcher<*> -> should(expected as Matcher<Node<T>>)63        else -> {64            val actual = this65            assertionCounter.inc()66            eq(actual, expected)?.let(errorCollector::collectOrThrow)67        }68    }69}70class StringTreeShow<T> : Show<T> {71    init {72        println("Create new StringTreeShow()")73    }74    override fun show(a: T): Printed {75        println("show()")76        if (a is Node<*>) {77            return TreePrinter().dumpToString(a.toStringTree()).show()78        } else {79            return "Not a tree".show()80        }81    }82}...

errorAndAssertionsScope.kt

Source:errorAndAssertionsScope.kt

...42/**43 * Pushes the provided [error] onto the [errorCollector] and throws if the configured collection mode is [ErrorCollectionMode.Hard]44 */45@ExperimentalKotest46internal fun ErrorCollector.pushErrorAndMaybeThrow(error: Throwable) {47   pushError(error)48   if (getCollectionMode() == ErrorCollectionMode.Hard) {49      throwCollectedErrors()50   }51}...

should.kt

Source:should.kt

1package io.kotest.matchers2import io.kotest.assertions.Actual3import io.kotest.assertions.Expected4import io.kotest.assertions.assertionCounter5import io.kotest.assertions.collectOrThrow6import io.kotest.assertions.eq.actualIsNull7import io.kotest.assertions.eq.eq8import io.kotest.assertions.eq.expectedIsNull9import io.kotest.assertions.errorCollector10import io.kotest.assertions.failure11import io.kotest.assertions.intellijFormatError12import io.kotest.assertions.show.show13@Suppress("UNCHECKED_CAST")14infix fun <T, U : T> T.shouldBe(expected: U?) {15   when (expected) {16      is Matcher<*> -> should(expected as Matcher<T>)17      else -> {18         val actual = this19         assertionCounter.inc()20         eq(actual, expected)?.let(errorCollector::collectOrThrow)21      }22   }23}24@Suppress("UNCHECKED_CAST")25infix fun <T> T.shouldNotBe(any: Any?) {26   when (any) {27      is Matcher<*> -> shouldNot(any as Matcher<T>)28      else -> shouldNot(equalityMatcher(any))29   }30}31infix fun <T> T.shouldHave(matcher: Matcher<T>) = should(matcher)32infix fun <T> T.should(matcher: Matcher<T>) {33   assertionCounter.inc()34   val result = matcher.test(this)35   if (!result.passed()) {36      errorCollector.collectOrThrow(failure(result.failureMessage()))37   }38}39infix fun <T> T.shouldNotHave(matcher: Matcher<T>) = shouldNot(matcher)40infix fun <T> T.shouldNot(matcher: Matcher<T>) = should(matcher.invert())41infix fun <T> T.should(matcher: (T) -> Unit) = matcher(this)42fun <T> be(expected: T) = equalityMatcher(expected)43fun <T> equalityMatcher(expected: T) = object : Matcher<T> {44   override fun test(value: T): MatcherResult {45      val t = if (value == null && expected == null) {46         null47      } else if (value == null && expected != null) {48         actualIsNull(expected)49      } else if (value != null && expected == null) {50         expectedIsNull(value)51      } else {52         eq(value, expected)53      }54      return MatcherResult(55         t == null,56         {57            val e = Expected(expected.show())58            val a = Actual(value.show())59            failure(e, a).message ?: intellijFormatError(e, a)60         },61         { "${expected.show().value} should not equal ${value.show().value}" }62      )63   }64}...

formatErrorSpec.kt

Source:formatErrorSpec.kt

1package playground2import io.kotest.assertions.Actual3import io.kotest.assertions.Expected4import io.kotest.assertions.eq.eq5import io.kotest.assertions.errorCollector6import io.kotest.assertions.failure7import io.kotest.assertions.print.print8import io.kotest.assertions.throwCollectedErrors9import io.kotest.assertions.withClue10import io.kotest.core.spec.style.ExpectSpec11import io.kotest.matchers.shouldBe12class FormatErrorSpec : ExpectSpec({13    context("intellij format errors") {14        expect("with shouldBe") {15            "foobar".shouldBe("foo")16        }17        expect("with eq") {18            eq("foobar", "foo")?.let { throw it }19        }20        expect("with failure") {21            failure(Expected("foo".print()), Actual("foobar".print())).let { throw it }22        }23        expect("with Error") {24            throw Error("""expected:<"foo"> but was:<"foobar">""")25        }26        expect("with clue and failure") {27            throw withClue("foo") {28                failure("""expected:<"foo"> but was:<"foobar">""")29            }30        }31        expect("with failure and build string") {32            throw failure(33                buildString {34                    appendLine("foo")35                    append("""expected:<"foo"> but was:<"foobar">""")36                }37            )38        }39        expect("with clue and multiple equality matchers") {40            throw failure(41                buildString {42                    appendLine("foo")43                    appendLine("""expected:<"foo"> but was:<"foobar">""")44                    appendLine()45                    appendLine("bar")46                    append("""expected:<"bar"> but was:<"foobar">""")47                }48            )49        }50        expect("with error collector") {51            errorCollector.pushError(failure("""expected:<"foo"> but was:<"foobar">"""))52            errorCollector.pushError(failure("""expected:<"bar"> but was:<"foobar">"""))53            errorCollector.throwCollectedErrors()54        }55    }56})...

one.kt

Source:one.kt

1package io.kotest.assertions2import io.kotest.common.ExperimentalKotest3/**4 * Executes the given lambda and expects exactly one assertion to succeed.5 * If zero, two or more assertions succeed then this will cause this block to fail.6 *7 * ```8 *   one {9 *      "foo" shouldBe "bar"10 *      "foo" shouldBe "foo11 *      "foo" shouldBe "baz"12 *   }13 * ```14 */15@ExperimentalKotest16suspend fun <T> one(assertions: suspend () -> T): T {17   val (result, failures, assertionsCount) = errorAndAssertionsScope { assertions() }18   assertionCounter.inc(assertionsCount)19   if (assertionsCount < 2) {20      errorCollector.collectOrThrow(failures + failure("One cannot ensure a mutual exclusion with less than two assertions"))21   }22   if (assertionsCount == failures.size + 1) {23      return result.getOrThrow()24   }25   errorCollector.pushErrors(failures)26   val f = when {27      assertionsCount == failures.size -> failure("One expected a single assertion to succeed, but none succeeded.")28      assertionsCount > failures.size + 1 -> failure("One expected a single assertion to succeed, but more than one succeeded.")29      else -> failure("One expected a single assertion to succeed, but there were more failures than assertions.")30   }31   errorCollector.pushErrorAndMaybeThrow(f)32   throw f // one/all/any won't respect softly for now33}34/**35 * Executes the given lambda and expects exactly one assertion to succeed.36 * If zero, two or more assertions suceed then this will cause an exception.37 *38 * Returns the original value [t] on success for use in subsequent assertions.39 */40@ExperimentalKotest41suspend fun <T> one(t: T, assertions: suspend T.(T) -> Unit) = one {42   t.assertions(t)43   t44}...

JsonExtensions.kt

Source:JsonExtensions.kt

1package testhelpers.extensions2import com.google.gson.Gson3import com.google.gson.GsonBuilder4import com.google.gson.JsonArray5import com.google.gson.JsonElement6import com.google.gson.JsonObject7import io.kotest.assertions.assertionCounter8import io.kotest.assertions.collectOrThrow9import io.kotest.assertions.eq.eq10import io.kotest.assertions.errorCollector11import okhttp3.mockwebserver.MockResponse12private fun String.determineJsonType(): Class<out JsonElement> = when {13    this.trimStart().startsWith("[") -> JsonArray::class.java14    else -> JsonObject::class.java15}16fun String.toComparableJson() = try {17    Gson().fromJson(this, this.determineJsonType()).toString()18} catch (e: Exception) {19    throw IllegalArgumentException("'$this' wasn't valid JSON")20}21fun String.toComparableJsonPretty(): String = try {22    val gson = GsonBuilder().setPrettyPrinting().create()23    val obj = gson.fromJson(this, this.determineJsonType())24    gson.toJson(obj)25} catch (e: Exception) {26    throw IllegalArgumentException("'$this' wasn't valid JSON")27}28@Suppress("UNCHECKED_CAST")29infix fun String.shouldMatchJson(expected: String) {30    val actualPretty = this.toComparableJsonPretty()31    val expectedPretty = expected.toComparableJsonPretty()32    assertionCounter.inc()33    eq(actualPretty, expectedPretty)?.let(errorCollector::collectOrThrow)34}35fun String.toJsonResponse(): MockResponse = MockResponse().setBody(this.toComparableJson())...

AssertionExtension.kt

Source:AssertionExtension.kt

1package com.example.realworld.util.extension2import com.fasterxml.jackson.databind.ObjectMapper3import io.kotest.assertions.assertionCounter4import io.kotest.assertions.collectOrThrow5import io.kotest.assertions.eq.eq6import io.kotest.assertions.errorCollector7infix fun <T> String.shouldBeEqualJson(expected: T) {8    val actual = this9    assertionCounter.inc()10    val expectedJson = ObjectMapper().writeValueAsString(expected)11    eq(actual, expectedJson)?.let(errorCollector::collectOrThrow)12}...

ErrorCollector

Using AI Code Generation

1val errorCollector = ErrorCollector()2expectThat(1).isLessThan(0).collectErrors(errorCollector)3expectThat(2).isGreaterThan(3).collectErrors(errorCollector)4expectThat(4).isLessThan(3).collectErrors(errorCollector)5val errorCollector = ErrorCollector()6expectThat(1).isLessThan(0).collectErrors(errorCollector)7expectThat(2).isGreaterThan(3).collectErrors(errorCollector)8expectThat(4).isLessThan(3).collectErrors(errorCollector)9val errorCollector = ErrorCollector()10expectThat(1).isLessThan(0).collectErrors(errorCollector)11expectThat(2).isGreaterThan(3).collectErrors(errorCollector)12expectThat(4).isLessThan(3).collectErrors(errorCollector)13val errorCollector = ErrorCollector()14expectThat(1).isLessThan(0).collectErrors(errorCollector)15expectThat(2).isGreaterThan(3).collectErrors(errorCollector)16expectThat(4).isLessThan(3).collectErrors(errorCollector)17val errorCollector = ErrorCollector()18expectThat(1).isLessThan(0).collectErrors(errorCollector)19expectThat(2).isGreaterThan(3).collectErrors(errorCollector)20expectThat(4).isLessThan(3).collectErrors(errorCollector)21val errorCollector = ErrorCollector()22expectThat(1).isLessThan(0).collectErrors(errorCollector)23expectThat(2).isGreaterThan(3).collectErrors(errorCollector)24expectThat(4).isLessThan(3).collectErrors(errorCollector)25val errorCollector = ErrorCollector()26expectThat(1).isLessThan(0).collectErrors(errorCollector)27expectThat(2).isGreaterThan(3).collectErrors(errorCollector)28expectThat(4).isLessThan(3).collectErrors(errorCollector)29val errorCollector = ErrorCollector()

ErrorCollector

Using AI Code Generation

1    fun `error collector`() {2        val collector = ErrorCollector()3        collector.collect("First error")4        collector.collect("Second error")5        collector.collect("Third error")6        collector.assertAll()7    }8    fun `error collector with lambda`() {9        ErrorCollector().collect {10        }11    }12}13        at io.kotest.assertions.ErrorCollector.assertAll(ErrorCollector.kt:37)14        at com.kotest.assertions.ErrorCollectorTest$error collector$1.invokeSuspend(ErrorCollectorTest.kt:16)15        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)16        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)17        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)18        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:738)19        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:678)20        at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:665)21        at io.kotest.assertions.ErrorCollector.assertAll(ErrorCollector.kt:37)22        at com.kotest.assertions.ErrorCollectorTest$error collector with lambda$2.invokeSuspend(ErrorCollectorTest.kt:25)23        at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)24        at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:56)25        at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:571)

ErrorCollector

Using AI Code Generation

1val collector = ErrorCollector()2collector.collect {3    expect(1).toBe(2)4}5collector.collect {6    expect(2).toBe(3)7}8collector.assertAll()9val collector = ErrorCollector()10collector.collect {11    expect(1).toBe(2)12}13collector.collect {14    expect(2).toBe(3)15}16collector.assertAll()17To use the ErrorCollector class, you need to import the io.kotest.assertions package. You can import the package in your test file as shown below:18import io.kotest.assertions.*19The ErrorCollector class is available in the io.kotest.assertions package. The collect() method takes a lambda that contains the assertions to be collected. The lambda can contain any number of assertions. If any of the assertions fail, the lambda will throw an AssertionError . The assertAll() method will collect all the failures and then throw an AssertionError with a message that contains all the failures. To use the ErrorCollector class, you need to import the io.kotest.assertions package. You can import the package in your test file as shown below: import io.kotest.assertions.*20The ErrorCollector class is available in the io.kotest.assertions package. The collect() method takes a lambda that contains the assertions to be collected. The lambda can contain any number of assertions. If any of the assertions fail, the lambda will throw an AssertionError . The assertAll() method will collect all the failures and then throw an AssertionError with a message that contains all the failures. To use the ErrorCollector class, you need to import the io.kotest.assertions package. You can import the package in your test file as shown below: import io.kotest.assertions.* import io.kotest.assertions.*21The ErrorCollector class is available in the io.kotest.assertions package. The collect() method takes a lambda that contains the assertions to be collected. The lambda can contain any number of assertions. If any of the assertions

ErrorCollector

Using AI Code Generation

1val collector = ErrorCollector()2collector.collect("result1 is not 3") { result1 == 3 }3collector.collect("result2 is not 4") { result2 == 4 }4collector.assertAll()5@Test fun test() { val collector = ErrorCollector() val result1 = 1 + 2 val result2 = 2 + 2 collector.collect("result1 is not 3") { result1 == 3 } collector.collect("result2 is not 4") { result2 == 4 } collector.assertAll() }6java.lang.AssertionError: The following 2 assertions failed: result1 is not 3 result2 is not 4 at io.kotest.assertions.ErrorCollector.assertAll(ErrorCollector.kt:59)7java.lang.AssertionError: The following 2 assertions failed: result1 is not 3 result2 is not 4 at io.kotest.assertions.ErrorCollector.assertAll(ErrorCollector.kt:59) at io.kotest.assertions.assertSoftly$lambda-1$lambda-0(assertions.kt:55) at io.kotest.assertions.assertSoftly$lambda-1(assertions.kt:54) at io.kotest.assertions.assertSoftly

ErrorCollector

Using AI Code Generation

1import io.kotest.assertions.*2import io.kotest.assertions.*3import io.kotest.assertions.*4import io.kotest.assertions.*5import io.kotest.assertions.*6import io.kotest.assertions.*7import io.kotest.assertions.*8import io.kotest.assertions.*9import io.kotest.assertions.*10import io.kotest.assertions.*11import io.kotest.assertions.*12import io.kotest.assertions.*13import io.kotest.assertions.*

ErrorCollector

Using AI Code Generation

1val errorCollector = ErrorCollector()2val result = errorCollector.assertAll {3"String should be equal" {4}5"String should not be equal" {6}7}8assertThat(result.passed).isEqualTo(1)9assertThat(result.failed).isEqualTo(1)10assertThat(result.errors).isEqualTo(1)11assertThat(result.throwable).isNotNull()12}13}14import io.kotest.assertions.*15import io.kotest.core.spec.style.*16import io.kotest.matchers.shouldBe17import io.kotest.matchers.shouldNotBe18import java.util.concurrent.TimeoutException19class ErrorCollectorTest : FunSpec({20test("assertAll with withClue") {21val errorCollector = ErrorCollector()22val result = errorCollector.assertAll {23withClue("test1") {24"String should be equal" {25}26}27withClue("test2") {28"String should not be equal" {29}30}31}32assertThat(result.passed).isEqualTo(1)33assertThat(result.failed).isEqualTo(1)34assertThat(result.errors).isEqualTo(1)35assertThat(result.throwable).isNotNull()36assertThat(result.toString()).isEqualTo("Result(passed=1, failed=1

ErrorCollector

Using AI Code Generation

1@Test fun test() {2val collector = ErrorCollector()3collector.collect("Error 1")4collector.collect("Error 2")5collector.collect("Error 3")6collector.assertEmpty()7}8@Test fun test() {9val collector = ErrorCollector()10collector.collect("Error 1")11collector.collect("Error 2")12collector.collect("Error 3")13collector.assertEmpty()14}15@DisplayName("Test for ErrorCollector")16@Test fun testErrorCollector() {17val collector = ErrorCollector()18collector.collect("Error 1")19collector.collect("Error 2")20collector.collect("Error 3")21collector.assertEmpty()22}

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.