Discover AI-native insights at Testμ Conference‘25

How to use TestCaseExecutionListenerToTestEngineListenerAdapter class of io.kotest.engine.test.listener package

Best Kotest code snippet using io.kotest.engine.test.listener.TestCaseExecutionListenerToTestEngineListenerAdapter

SingleInstanceSpecRunner.kt

...12import io.kotest.engine.spec.Materializer13import io.kotest.engine.spec.SpecExtensions14import io.kotest.engine.spec.SpecRunner15import io.kotest.engine.test.TestCaseExecutor16import io.kotest.engine.test.listener.TestCaseExecutionListenerToTestEngineListenerAdapter17import io.kotest.engine.test.scheduler.TestScheduler18import io.kotest.engine.test.scopes.DuplicateNameHandlingTestScope19import io.kotest.mpp.Logger20import io.kotest.mpp.bestName21import kotlinx.coroutines.coroutineScope22import java.util.concurrent.ConcurrentHashMap23import kotlin.coroutines.CoroutineContext24/**25 * Implementation of [SpecRunner] that executes all tests against the26 * same [Spec] instance. In other words, only a single instance of the spec class27 * is instantiated for all the test cases.28 */29@ExperimentalKotest30internal class SingleInstanceSpecRunner(31   listener: TestEngineListener,32   scheduler: TestScheduler,33   private val defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory,34   private val configuration: ProjectConfiguration,35) : SpecRunner(listener, scheduler, configuration) {36   private val results = ConcurrentHashMap<TestCase, TestResult>()37   private val extensions = SpecExtensions(configuration.registry)38   private val logger = Logger(SingleInstanceSpecRunner::class)39   override suspend fun execute(spec: Spec): Result<Map<TestCase, TestResult>> {40      logger.log { Pair(spec::class.bestName(), "executing spec $spec") }41      suspend fun interceptAndRun(context: CoroutineContext) = runCatching {42         val rootTests = materializer.materialize(spec)43         logger.log { Pair(spec::class.bestName(), "Materialized root tests: ${rootTests.size}") }44         launch(spec) {45            logger.log { Pair(it.name.testName, "Executing test $it") }46            runTest(it, context, null)47         }48      }49      try {50         return coroutineScope {51            extensions.beforeSpec(spec)52               .flatMap { interceptAndRun(coroutineContext) }53               .flatMap { SpecExtensions(configuration.registry).afterSpec(spec) }54               .map { results }55         }56      } catch (e: Exception) {57         e.printStackTrace()58         throw e59      }60   }61   /**62    * A [TestScope] that runs discovered tests as soon as they are registered in the same spec instance.63    *64    * This implementation tracks fail fast if configured via TestCase config or globally.65    */66   inner class SingleInstanceTestScope(67      override val testCase: TestCase,68      override val coroutineContext: CoroutineContext,69      private val parentScope: SingleInstanceTestScope?,70   ) : TestScope {71      // set to true if we failed fast and should ignore further tests72      private var skipRemaining = false73      // in the single instance runner we execute each nested test as soon as they are registered74      override suspend fun registerTestCase(nested: NestedTest) {75         logger.log { Pair(testCase.name.testName, "Nested test case discovered '${nested}") }76         val nestedTestCase = Materializer(configuration).materialize(nested, testCase)77         if (skipRemaining) {78            logger.log { Pair(testCase.name.testName, "Skipping test due to fail fast") }79            listener.testIgnored(nestedTestCase, "Skipping test due to fail fast")80         } else {81            // if running this nested test results in an error, we won't launch anymore nested tests82            val result = runTest(nestedTestCase, coroutineContext, this@SingleInstanceTestScope)83            if (result.isErrorOrFailure) {84               if (testCase.config.failfast || configuration.projectWideFailFast) {85                  logger.log { Pair(testCase.name.testName, "Test failed - setting skipRemaining = true") }86                  skipRemaining = true87                  parentScope?.skipRemaining = true88               }89            }90         }91      }92   }93   private suspend fun runTest(94      testCase: TestCase,95      coroutineContext: CoroutineContext,96      parentScope: SingleInstanceTestScope?,97   ): TestResult {98      val testExecutor = TestCaseExecutor(99         TestCaseExecutionListenerToTestEngineListenerAdapter(listener),100         defaultCoroutineDispatcherFactory,101         configuration,102      )103      val scope = DuplicateNameHandlingTestScope(104         configuration.duplicateTestNameMode,105         SingleInstanceTestScope(testCase, coroutineContext, parentScope)106      )107      val result = testExecutor.execute(testCase, scope)108      results[testCase] = result109      return result110   }111}...

createSpecExecutorDelegate.kt

Source: createSpecExecutorDelegate.kt

...8import io.kotest.engine.listener.TestEngineListener9import io.kotest.engine.test.TestCaseExecutor10import io.kotest.engine.test.scopes.DuplicateNameHandlingTestScope11import io.kotest.engine.test.scopes.InOrderTestScope12import io.kotest.engine.test.listener.TestCaseExecutionListenerToTestEngineListenerAdapter13import io.kotest.mpp.log14import kotlin.coroutines.coroutineContext15@ExperimentalKotest16internal actual fun createSpecExecutorDelegate(17   listener: TestEngineListener,18   defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory,19   configuration: ProjectConfiguration,20): SpecExecutorDelegate =21   DefaultSpecExecutorDelegate(listener, defaultCoroutineDispatcherFactory, configuration)22/**23 * A [SpecExecutorDelegate] that executes tests sequentially, using the calling thread24 * as the execution context for timeouts.25 */26@ExperimentalKotest27internal class DefaultSpecExecutorDelegate(28   private val listener: TestEngineListener,29   private val coroutineDispatcherFactory: CoroutineDispatcherFactory,30   private val configuration: ProjectConfiguration31) : SpecExecutorDelegate {32   private val materializer = Materializer(configuration)33   override suspend fun execute(spec: Spec): Map<TestCase, TestResult> {34      log { "DefaultSpecExecutorDelegate: Executing spec $spec" }35      materializer.materialize(spec)36         .forEach { testCase ->37            log { "DefaultSpecExecutorDelegate: Executing testCase $testCase" }38            val context = DuplicateNameHandlingTestScope(39               configuration.duplicateTestNameMode,40               InOrderTestScope(41                  testCase,42                  coroutineContext,43                  configuration.duplicateTestNameMode,44                  listener,45                  coroutineDispatcherFactory,46                  configuration47               )48            )49            TestCaseExecutor(50               TestCaseExecutionListenerToTestEngineListenerAdapter(listener),51               coroutineDispatcherFactory,52               configuration53            ).execute(testCase, context)54         }55      return emptyMap()56   }57}...

InOrderTestScope.kt

Source: InOrderTestScope.kt

...9import io.kotest.core.test.TestScope10import io.kotest.engine.listener.TestEngineListener11import io.kotest.engine.spec.Materializer12import io.kotest.engine.test.TestCaseExecutor13import io.kotest.engine.test.listener.TestCaseExecutionListenerToTestEngineListenerAdapter14import io.kotest.mpp.log15import kotlin.coroutines.CoroutineContext16/**17 * A [TestScope] that executes nested tests as soon as they are discovered.18 */19@ExperimentalKotest20class InOrderTestScope(21   override val testCase: TestCase,22   override val coroutineContext: CoroutineContext,23   private val mode: DuplicateTestNameMode,24   private val listener: TestEngineListener,25   private val coroutineDispatcherFactory: CoroutineDispatcherFactory,26   private val configuration: ProjectConfiguration,27) : TestScope {28   private var failed = false29   override suspend fun registerTestCase(nested: NestedTest) {30      log { "InOrderTestScope: Nested test case discovered $nested" }31      val nestedTestCase = Materializer(configuration).materialize(nested, testCase)32      if (failed && (testCase.config.failfast || configuration.projectWideFailFast)) {33         log { "InOrderTestScope: A previous nested test failed and failfast is enabled - will mark this as ignored" }34         listener.testIgnored(nestedTestCase, "Failfast enabled on parent test")35      } else {36         val result = runTest(nestedTestCase, coroutineContext)37         if (result.isErrorOrFailure) {38            failed = true39         }40      }41   }42   private suspend fun runTest(43      testCase: TestCase,44      coroutineContext: CoroutineContext,45   ): TestResult {46      return TestCaseExecutor(47         TestCaseExecutionListenerToTestEngineListenerAdapter(listener),48         coroutineDispatcherFactory,49         configuration,50      ).execute(51         testCase,52         createSingleInstanceTestScope(53            testCase,54            coroutineContext,55            mode,56            listener,57            coroutineDispatcherFactory,58            configuration,59         )60      )61   }...

TestCaseExecutionListenerToTestEngineListenerAdapter.kt

Source: TestCaseExecutionListenerToTestEngineListenerAdapter.kt

...5import io.kotest.engine.test.TestCaseExecutionListener6/**7 * Converts events fired to a [TestCaseExecutionListener] into events fired to a [TestEngineListener]8 */9class TestCaseExecutionListenerToTestEngineListenerAdapter(10   private val listener: TestEngineListener11) : TestCaseExecutionListener {12   override suspend fun testFinished(testCase: TestCase, result: TestResult) {13      listener.testFinished(testCase, result)14   }15   override suspend fun testIgnored(testCase: TestCase, reason: String?) {16      listener.testIgnored(testCase, reason)17   }18   override suspend fun testStarted(testCase: TestCase) {19      listener.testStarted(testCase)20   }21}...

Blogs

Check out the latest blogs from LambdaTest on this topic:

Pair testing strategy in an Agile environment

Pair testing can help you complete your testing tasks faster and with higher quality. But who can do pair testing, and when should it be done? And what form of pair testing is best for your circumstance? Check out this blog for more information on how to conduct pair testing to optimize its benefits.

20 Best VS Code Extensions For 2023

With the change in technology trends, there has been a drastic change in the way we build and develop applications. It is essential to simplify your programming requirements to achieve the desired outcomes in the long run. Visual Studio Code is regarded as one of the best IDEs for web development used by developers.

How To Get Started With Cypress Debugging

One of the most important tasks of a software developer is not just writing code fast; it is the ability to find what causes errors and bugs whenever you encounter one and the ability to solve them quickly.

Running Tests In Cypress With GitHub Actions [Complete Guide]

In today’s tech world, where speed is the key to modern software development, we should aim to get quick feedback on the impact of any change, and that is where CI/CD comes in place.

QA’s and Unit Testing – Can QA Create Effective Unit Tests

Unit testing is typically software testing within the developer domain. As the QA role expands in DevOps, QAOps, DesignOps, or within an Agile team, QA testers often find themselves creating unit tests. QA testers may create unit tests within the code using a specified unit testing tool, or independently using a variety of methods.

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.