How to use AbstractTestEngineListener class of io.kotest.engine.listener package

Best Kotest code snippet using io.kotest.engine.listener.AbstractTestEngineListener

AfterProjectListenerExceptionTest.kt

Source:AfterProjectListenerExceptionTest.kt

...4import io.kotest.core.annotation.Isolate5import io.kotest.core.spec.style.FunSpec6import io.kotest.engine.TestEngineLauncher7import io.kotest.engine.extensions.ExtensionException8import io.kotest.engine.listener.AbstractTestEngineListener9import io.kotest.inspectors.forOne10import io.kotest.matchers.collections.shouldHaveSize11import io.kotest.matchers.throwable.shouldHaveMessage12import io.kotest.matchers.types.shouldBeInstanceOf13@Isolate14class AfterProjectListenerExceptionTest : FunSpec({15   test("exception in afterProject should use AfterProjectListenerException") {16      val projectListener = object : ProjectListener {17         override suspend fun afterProject() {18            error("ARRGH")19         }20      }21      val errors: MutableList<Throwable> = mutableListOf()22      val listener = object : AbstractTestEngineListener() {23         override suspend fun engineFinished(t: List<Throwable>) {24            errors.addAll(t)25         }26      }27      val c = ProjectConfiguration()28      c.registry.add(projectListener)29      TestEngineLauncher(listener)30         .withClasses(DummySpec7::class)31         .withConfiguration(c)32         .launch()33      errors shouldHaveSize 134      errors[0].shouldBeInstanceOf<ExtensionException.AfterProjectException>()35      errors[0].cause!! shouldHaveMessage "ARRGH"36   }37   test("multiple afterProject exceptions should be collected") {38      val projectListener1 = object : ProjectListener {39         override suspend fun afterProject() {40            error("GLIPP")41         }42      }43      val projectListener2 = object : ProjectListener {44         override suspend fun afterProject() {45            error("WHACK")46         }47      }48      val errors: MutableList<Throwable> = mutableListOf()49      val listener = object : AbstractTestEngineListener() {50         override suspend fun engineFinished(t: List<Throwable>) {51            errors.addAll(t)52         }53      }54      val c = ProjectConfiguration()55      c.registry.add(projectListener1)56      c.registry.add(projectListener2)57      TestEngineLauncher(listener)58         .withClasses(DummySpec7::class)59         .withConfiguration(c)60         .launch()61      errors shouldHaveSize 262      errors.filterIsInstance<ExtensionException.AfterProjectException>() shouldHaveSize 263      errors.forOne {...

BeforeProjectListenerExceptionTest.kt

Source:BeforeProjectListenerExceptionTest.kt

...4import io.kotest.core.annotation.Isolate5import io.kotest.core.spec.style.FunSpec6import io.kotest.engine.TestEngineLauncher7import io.kotest.engine.extensions.ExtensionException8import io.kotest.engine.listener.AbstractTestEngineListener9import io.kotest.inspectors.forOne10import io.kotest.matchers.collections.shouldHaveSize11import io.kotest.matchers.throwable.shouldHaveMessage12import io.kotest.matchers.types.shouldBeInstanceOf13@Isolate14class BeforeProjectListenerExceptionTest : FunSpec({15   test("exception in beforeProject should use BeforeProjectListenerException") {16      val errors: MutableList<Throwable> = mutableListOf()17      val listener = object : AbstractTestEngineListener() {18         override suspend fun engineFinished(t: List<Throwable>) {19            errors.addAll(t)20         }21      }22      val c = ProjectConfiguration()23      c.registry.add(object : ProjectListener {24         override suspend fun beforeProject() {25            error("OOOFF")26         }27      })28      TestEngineLauncher(listener)29         .withClasses(DummySpec3::class)30         .withConfiguration(c)31         .launch()32      errors shouldHaveSize 133      errors[0].shouldBeInstanceOf<ExtensionException.BeforeProjectException>()34      errors[0].cause!! shouldHaveMessage "OOOFF"35   }36   test("multiple beforeProject exceptions should be collected") {37      val projectListener1 = object : ProjectListener {38         override suspend fun beforeProject() {39            error("ZLOPP")40         }41      }42      val projectListener2 = object : ProjectListener {43         override suspend fun beforeProject() {44            error("WHAMM")45         }46      }47      val errors: MutableList<Throwable> = mutableListOf()48      val listener = object : AbstractTestEngineListener() {49         override suspend fun engineFinished(t: List<Throwable>) {50            errors.addAll(t)51         }52      }53      val c = ProjectConfiguration()54      c.registry.add(projectListener1)55      c.registry.add(projectListener2)56      TestEngineLauncher(listener)57         .withClasses(DummySpec3::class)58         .withConfiguration(c)59         .launch()60      errors shouldHaveSize 261      errors.filterIsInstance<ExtensionException.BeforeProjectException>() shouldHaveSize 262      errors.forOne {...

LauncherTestFilterTest.kt

Source:LauncherTestFilterTest.kt

...5import io.kotest.core.filter.TestFilterResult6import io.kotest.core.spec.style.FunSpec7import io.kotest.core.test.TestCase8import io.kotest.engine.TestEngineLauncher9import io.kotest.engine.listener.AbstractTestEngineListener10private var counter = 011/**12 * A [TestFilter] added via the launcher should filter tests out.13 */14@Isolate15class LauncherTestFilterTest : FunSpec() {16   init {17      // disabled until filters can be added to one launcher independently18      test("!filter added via launcher should filter test cases") {19         val filter = object : TestFilter {20            override fun filter(descriptor: Descriptor): TestFilterResult {21               return if (descriptor.id.value == "a") TestFilterResult.Include else TestFilterResult.Exclude(null)22            }23         }24         val listener = object : AbstractTestEngineListener() {25            override suspend fun testStarted(testCase: TestCase) {26               if (testCase.descriptor.id.value == "b")27                  error("should not run")28            }29         }30         TestEngineLauncher(listener)31            .withClasses(MyTestClass::class)32            .withExtensions(filter)33            .launch()34      }35      test("!filter with test path added via launcher should filter test cases") {36         val filter = object : TestFilter {37            override fun filter(descriptor: Descriptor): TestFilterResult {38               return if (descriptor.id.value == "a") TestFilterResult.Include else TestFilterResult.Exclude(null)39            }40         }41         val listener = object : AbstractTestEngineListener() {42            override suspend fun testStarted(testCase: TestCase) {43               if (testCase.descriptor.id.value == "b")44                  error("should not run")45            }46         }47         TestEngineLauncher(listener)48            .withClasses(MyTestClass::class)49            .withExtensions(filter)50            .launch()51      }52   }53}54private class MyTestClass : FunSpec() {55   init {...

TestEngineStartedFinishedInterceptorTest.kt

Source:TestEngineStartedFinishedInterceptorTest.kt

...3import io.kotest.core.spec.style.FunSpec4import io.kotest.engine.EngineResult5import io.kotest.engine.interceptors.EngineContext6import io.kotest.engine.interceptors.TestEngineStartedFinishedInterceptor7import io.kotest.engine.listener.AbstractTestEngineListener8import io.kotest.matchers.collections.shouldHaveSize9import io.kotest.matchers.shouldBe10@KotestInternal11class TestEngineStartedFinishedInterceptorTest : FunSpec({12   test("should invoke engineStarted before downstream") {13      var fired = ""14      val listener = object : AbstractTestEngineListener() {15         override suspend fun engineStarted() {16            fired += "a"17         }18      }19      TestEngineStartedFinishedInterceptor.intercept(20         EngineContext.empty.mergeListener(listener)21      ) {22         fired += "b"23         EngineResult.empty24      }25      fired.shouldBe("ab")26   }27   test("should invoke engineFinished after downstream") {28      var fired = ""29      val listener = object : AbstractTestEngineListener() {30         override suspend fun engineFinished(t: List<Throwable>) {31            fired += "a"32         }33      }34      TestEngineStartedFinishedInterceptor.intercept(35         EngineContext.empty.mergeListener(listener)36      ) {37         fired += "b"38         EngineResult(listOf(Exception("foo")))39      }40      fired.shouldBe("ba")41   }42   test("should invoke engineFinished with errors") {43      var errors = emptyList<Throwable>()44      val listener = object : AbstractTestEngineListener() {45         override suspend fun engineFinished(t: List<Throwable>) {46            errors = t47         }48      }49      TestEngineStartedFinishedInterceptor.intercept(50         EngineContext.empty.mergeListener(listener)51      ) { EngineResult(listOf(Exception("foo"))) }52      errors.shouldHaveSize(1)53   }54})...

KotestUnit.kt

Source:KotestUnit.kt

...3import io.kotest.core.spec.Spec4import io.kotest.core.test.TestCase5import io.kotest.core.test.TestResult6import io.kotest.engine.TestEngineLauncher7import io.kotest.engine.listener.AbstractTestEngineListener8import kotlinx.coroutines.runBlocking9import org.pitest.testapi.Description10import org.pitest.testapi.ResultCollector11import org.pitest.testapi.TestUnit12import kotlin.reflect.KClass13class KotestUnit(val klass: KClass<out Spec>) : TestUnit {14   override fun getDescription(): Description = Description(klass.toDescriptor().path().value, klass.java)15   override fun execute(rc: ResultCollector) = runBlocking<Unit> {16      val listener = object : AbstractTestEngineListener() {17         private val started = mutableSetOf<io.kotest.core.descriptors.Descriptor.TestDescriptor>()18         private val completed = mutableSetOf<io.kotest.core.descriptors.Descriptor.TestDescriptor>()19         override suspend fun testStarted(testCase: TestCase) {20            if (started.add(testCase.descriptor))21               rc.notifyStart(Description(testCase.descriptor.path().value, klass.java))22         }23         override suspend fun testFinished(testCase: TestCase, result: TestResult) {24            val desc = Description(testCase.descriptor.path().value, klass.java)25            if (completed.add(testCase.descriptor)) {26               when (result.errorOrNull) {27                  null -> rc.notifyEnd(desc)28                  else -> rc.notifyEnd(desc, result.errorOrNull)29               }30            }...

CompositeTestEngineListenerTest.kt

Source:CompositeTestEngineListenerTest.kt

1package com.sksamuel.kotest.engine.listener2import io.kotest.core.spec.style.FunSpec3import io.kotest.core.test.TestResult4import io.kotest.engine.listener.AbstractTestEngineListener5import io.kotest.engine.listener.CompositeTestEngineListener6import io.kotest.matchers.shouldBe7import kotlin.reflect.KClass8import kotlin.time.Duration.Companion.seconds9class CompositeTestEngineListenerTest : FunSpec({10   test("specStarted should fire for all listeners") {11      var fired1 = false12      var fired2 = false13      val l1 = object : AbstractTestEngineListener() {14         override suspend fun specStarted(kclass: KClass<*>) {15            fired1 = true16         }17      }18      val l2 = object : AbstractTestEngineListener() {19         override suspend fun specStarted(kclass: KClass<*>) {20            fired2 = true21         }22      }23      CompositeTestEngineListener(listOf(l1, l2)).specStarted(CompositeTestEngineListenerTest::class)24      fired1 shouldBe true25      fired2 shouldBe true26   }27   test("specFinished should fire for all listeners") {28      var fired1 = false29      var fired2 = false30      val l1 = object : AbstractTestEngineListener() {31         override suspend fun specFinished(kclass: KClass<*>, result: TestResult) {32            fired1 = true33         }34      }35      val l2 = object : AbstractTestEngineListener() {36         override suspend fun specFinished(kclass: KClass<*>, result: TestResult) {37            fired2 = true38         }39      }40      CompositeTestEngineListener(listOf(l1, l2)).specFinished(41         CompositeTestEngineListenerTest::class,42         TestResult.Success(0.seconds)43      )44      fired1 shouldBe true45      fired2 shouldBe true46   }47})...

SpecStartedFinishedInterceptorTest.kt

Source:SpecStartedFinishedInterceptorTest.kt

1package com.sksamuel.kotest.engine.spec.interceptor2import io.kotest.core.spec.SpecRef3import io.kotest.core.spec.style.FunSpec4import io.kotest.core.test.TestResult5import io.kotest.engine.listener.AbstractTestEngineListener6import io.kotest.engine.spec.interceptor.SpecFinishedInterceptor7import io.kotest.engine.spec.interceptor.SpecStartedInterceptor8import io.kotest.matchers.shouldBe9import kotlin.reflect.KClass10class SpecStartedFinishedInterceptorTest : FunSpec() {11   init {12      test("SpecStartedInterceptor should call specStarted before invoking spec") {13         var result = ""14         val listener = object : AbstractTestEngineListener() {15            override suspend fun specStarted(kclass: KClass<*>) {16               result += "a"17            }18         }19         SpecStartedInterceptor(listener)20            .intercept(SpecRef.Reference(FooSpec::class)) {21               result += "b"22               Result.success(emptyMap())23            }24         result shouldBe "ab"25      }26      test("SpecFinishedInterceptor should call specFinished after invoking spec") {27         var r = ""28         val listener = object : AbstractTestEngineListener() {29            override suspend fun specFinished(kclass: KClass<*>, result: TestResult) {30               r += "a"31            }32         }33         SpecFinishedInterceptor(listener)34            .intercept(SpecRef.Reference(FooSpec::class)) {35               r += "b"36               Result.success(emptyMap())37            }38         r shouldBe "ba"39      }40   }41}42private class FooSpec : FunSpec()...

TestEngineInitializeInterceptorTest.kt

Source:TestEngineInitializeInterceptorTest.kt

2import io.kotest.core.spec.style.FunSpec3import io.kotest.engine.EngineResult4import io.kotest.engine.interceptors.EngineContext5import io.kotest.engine.interceptors.TestEngineInitializedInterceptor6import io.kotest.engine.listener.AbstractTestEngineListener7import io.kotest.matchers.booleans.shouldBeTrue8class TestEngineInitializeInterceptorTest : FunSpec({9   test("should invoke initialize") {10      var fired = false11      val listener = object : AbstractTestEngineListener() {12         override suspend fun engineInitialized(context: EngineContext) {13            fired = true14         }15      }16      TestEngineInitializedInterceptor.intercept(17         EngineContext.empty.mergeListener(listener)18      ) { EngineResult.empty }19      fired.shouldBeTrue()20   }21})...

AbstractTestEngineListener

Using AI Code Generation

1import io.kotest.core.spec.style.FunSpec2import io.kotest.engine.listener.AbstractTestEngineListener3import io.kotest.engine.listener.TestEngineListener4import io.kotest.core.spec.Spec5import io.kotest.core.test.TestCase6import io.kotest.core.test.TestResult7class AbstractTestEngineListenerTest : FunSpec() {8override fun listeners(): List<TestEngineListener> =9listOf(object : AbstractTestEngineListener() {10override fun engineStarted(classes: List<KClass<out Spec>>) {11println("engine started")12}13override fun engineFinished(t: List<Throwable>) {14println("engine finished")15}16override fun specStarted(kclass: KClass<out Spec>) {17println("spec started")18}19override fun specFinished(kclass: KClass<out Spec>, t: Throwable?) {20println("spec finished")21}22override fun testStarted(testCase: TestCase) {23println("test started")24}25override fun testFinished(testCase: TestCase, result: TestResult) {26println("test finished")27}28})29init {30test("test case") {31}32}33}

AbstractTestEngineListener

Using AI Code Generation

1val listener = object : AbstractTestEngineListener() {2override fun engineStarted(totals: EngineTestCounts) {3println("Engine started")4}5override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {6println("Engine finished")7}8}9val listener = object : AbstractTestEngineListener() {10override fun engineStarted(totals: EngineTestCounts) {11println("Engine started")12}13override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {14println("Engine finished")15}16}17val listener = object : AbstractTestEngineListener() {18override fun engineStarted(totals: EngineTestCounts) {19println("Engine started")20}21override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {22println("Engine finished")23}24}25val listener = object : AbstractTestEngineListener() {26override fun engineStarted(totals: EngineTestCounts) {27println("Engine started")28}29override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {30println("Engine finished")31}32}33val listener = object : AbstractTestEngineListener() {34override fun engineStarted(totals: EngineTestCounts) {35println("Engine started")36}37override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {38println("Engine finished")39}40}41val listener = object : AbstractTestEngineListener() {42override fun engineStarted(totals: EngineTestCounts) {43println("Engine started")44}45override fun engineFinished(totals: EngineTestCounts, results: Map<TestCase, TestResult>) {46println("Engine finished")47}48}49val listener = object : AbstractTestEngineListener() {50override fun engineStarted(totals: EngineTestCounts) {51println("Engine started")52}53override fun engineFinished(tot

AbstractTestEngineListener

Using AI Code Generation

1import io.kotest.core.spec.style.FunSpec2import io.kotest.core.spec.style.WordSpec3import io.kotest.core.test.TestCase4import io.kotest.core.test.TestResult5import io.kotest.engine.listener.AbstractTestEngineListener6import io.kotest.engine.listener.TestEngineListener7import io.kotest.matchers.shouldBe8class TestEngineListenerTest : WordSpec() {9    init {10        val listener = object : AbstractTestEngineListener() {11            override suspend fun testFinished(testCase: TestCase, result: TestResult) {12                println("Test finished: ${testCase.displayName}")13            }14        }15        val listener2 = object : TestEngineListener {16            override suspend fun testFinished(testCase: TestCase, result: TestResult) {17                println("Test finished: ${testCase.displayName}")18            }19        }20        "A test engine listener" should {21            "be able to listen to test events" {22            }23        }24    }25}26import io.kotest.core.spec.style.FunSpec27import io.kotest.core.spec.style.WordSpec28import io.kotest.core.test.TestCase29import io.kotest.core.test.TestResult30import io.kotest.engine.listener.TestEngineListener31import io.kotest.matchers.shouldBe32class TestEngineListenerTest : WordSpec() {33    init {34        val listener = object : TestEngineListener {35            override suspend fun testFinished(testCase: TestCase, result: TestResult) {36                println("Test finished: ${testCase.displayName}")37            }38        }39        "A test engine listener" should {40            "be able to listen to test events" {41            }42        }43    }44}45Kotest provides a TestEngineListener interface to listen to test events. This is useful if you want to perform some action before or after each test. The TestEngineListener interface has two methods which are called before and after each test. The testFinished() method is called after each test. The testStarted() method is called before

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.