TestMu Conference is Back! Future of Testing + AIRegister for Free

How to use DuplicateNameHandlingTestScope class of io.kotest.engine.test.scopes package

Best Kotest code snippet using io.kotest.engine.test.scopes.DuplicateNameHandlingTestScope

InstancePerLeafSpecRunner.kt

Source:InstancePerLeafSpecRunner.kt

...16import io.kotest.engine.spec.SpecRunner17import io.kotest.engine.test.TestCaseExecutionListener18import io.kotest.engine.test.TestCaseExecutor19import io.kotest.engine.test.scheduler.TestScheduler20import io.kotest.engine.test.scopes.DuplicateNameHandlingTestScope21import io.kotest.mpp.Logger22import io.kotest.mpp.bestName23import kotlinx.coroutines.coroutineScope24import java.util.*25import java.util.concurrent.atomic.AtomicInteger26import kotlin.coroutines.CoroutineContext27@ExperimentalKotest28internal class InstancePerLeafSpecRunner(29   listener: TestEngineListener,30   scheduler: TestScheduler,31   private val defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory,32   private val configuration: ProjectConfiguration,33) : SpecRunner(listener, scheduler, configuration) {34   private val logger = Logger(InstancePerLeafSpecRunner::class)35   private val extensions = SpecExtensions(configuration.registry)36   private val results = mutableMapOf<TestCase, TestResult>()37   // keeps track of tests we've already discovered38   private val seen = mutableSetOf<Descriptor>()39   // keeps track of tests we've already notified the listener about40   private val ignored = mutableSetOf<Descriptor>()41   private val started = mutableSetOf<Descriptor>()42   // we keep a count to break ties (first discovered)43   data class Enqueued(val testCase: TestCase, val count: Int)44   private val counter = AtomicInteger(0)45   // the queue contains tests discovered to run next. We always run the tests with the "furthest" path first.46   private val queue = PriorityQueue(Comparator<Enqueued> { o1, o2 ->47      val o1s = o1.testCase.descriptor.depth()48      val o2s = o2.testCase.descriptor.depth()49      if (o1s == o2s) o1.count.compareTo(o2.count) else o2s.compareTo(o1s)50   })51   // enqueues a test case that will execute in it's own spec instance52   private fun enqueue(testCase: TestCase) {53      queue.add(Enqueued(testCase, counter.incrementAndGet()))54   }55   /**56    * The intention of this runner is that each leaf [TestCase] executes in its own instance57    * of the containing [Spec] class.58    */59   override suspend fun execute(spec: Spec): Result<Map<TestCase, TestResult>> =60      runCatching {61         // we start by queuing up each root test to run in its own spec instance62         // when we find a leaf test for that instance, the spec is coloured and cannot be63         // used for further leaf tests.64         materializer.materialize(spec).forEach { root -> enqueue(root) }65         // with the queue seeded with the roots, we can keep picking a test from the queue66         // until it is empty. When it is empty that means all tests have finished and nothing67         // new is left to be found to be added to the queue68         while (queue.isNotEmpty()) {69            val (testCase, _) = queue.remove()70            executeInCleanSpec(testCase).getOrThrow()71         }72         results73      }74   private suspend fun executeInCleanSpec(test: TestCase): Result<Spec> {75      return createInstance(test.spec::class).flatMap { spec ->76         extensions.intercept(spec) {77            locateAndRunRoot(spec, test)78         } ?: Result.success(spec)79      }80   }81   // when we start a test from the queue, we must find the root test that is the ancestor of our82   // target test and begin executing that.83   private suspend fun locateAndRunRoot(spec: Spec, test: TestCase): Result<Spec> = runCatching {84      val root = materializer.materialize(spec)85         .firstOrNull { it.descriptor == test.descriptor.root() }86         ?: throw error("Unable to locate root test ${test.descriptor.path()}")87      logger.log { Pair(spec::class.bestName(), "Searching root '${root.name.testName}' for '${test.name.testName}'") }88      extensions.beforeSpec(spec).getOrThrow()89      locateAndRunRoot(root, test)90      extensions.afterSpec(spec).getOrThrow()91      spec92   }93   private suspend fun locateAndRunRoot(test: TestCase, target: TestCase) {94      logger.log { Pair(test.name.testName, "Executing test in search of target '${target.name.testName}'") }95      coroutineScope {96         val context = object : TestScope {97            var open = true98            override val testCase: TestCase = test99            override val coroutineContext: CoroutineContext = this@coroutineScope.coroutineContext100            override suspend fun registerTestCase(nested: NestedTest) {101               val t = Materializer(configuration).materialize(nested, testCase)102               // if this test is our target then we definitely run it103               // or if the test is on the path to our target we must run it104               if (t.descriptor.isOnPath(target.descriptor)) {105                  open = false106                  seen.add(t.descriptor)107                  locateAndRunRoot(t, target)108                  // otherwise, if we're already past our target we are finding new tests and so109                  // the first new test we run, the rest we queue110               } else if (target.descriptor.isOnPath(t.descriptor)) {111                  if (seen.add(t.descriptor)) {112                     if (open) {113                        open = false114                        locateAndRunRoot(t, target)115                     } else {116                        enqueue(t)117                     }118                  }119               }120            }121         }122         val context2 = DuplicateNameHandlingTestScope(configuration.duplicateTestNameMode, context)123         val testExecutor = TestCaseExecutor(124            object : TestCaseExecutionListener {125               override suspend fun testStarted(testCase: TestCase) {126                  if (started.add(testCase.descriptor)) {127                     logger.log { Pair(test.name.testName, "Notifying test started '${testCase.name.testName}'") }128                     listener.testStarted(testCase)129                  }130               }131               override suspend fun testIgnored(testCase: TestCase, reason: String?) {132                  if (ignored.add(testCase.descriptor))133                     logger.log { Pair(test.name.testName, "Notifying test ignored '${testCase.name.testName}'") }134                  listener.testIgnored(testCase, reason)135               }136               override suspend fun testFinished(testCase: TestCase, result: TestResult) {...

InstancePerTestSpecRunner.kt

Source:InstancePerTestSpecRunner.kt

...15import io.kotest.engine.spec.SpecRunner16import io.kotest.engine.test.TestCaseExecutionListener17import io.kotest.engine.test.TestCaseExecutor18import io.kotest.engine.test.scheduler.TestScheduler19import io.kotest.engine.test.scopes.DuplicateNameHandlingTestScope20import io.kotest.mpp.log21import kotlinx.coroutines.coroutineScope22import java.util.concurrent.ConcurrentHashMap23import kotlin.coroutines.CoroutineContext24/**25 * Implementation of [SpecRunner] that executes each [TestCase] in a fresh instance26 * of the [Spec] class.27 *28 * This differs from the [InstancePerLeafSpecRunner] in that29 * every single test, whether of type [TestType.Test] or [TestType.Container], will be30 * executed separately. Branch tests will ultimately be executed once as a standalone31 * test, and also as part of the "path" to any nested tests.32 *33 * So, given the following structure:34 *35 *  outerTest {36 *    innerTestA {37 *      // test38 *    }39 *    innerTestB {40 *      // test41 *    }42 *  }43 *44 * Three spec instances will be created. The execution process will be:45 *46 * spec1 = instantiate spec47 * spec1.outerTest48 * spec2 = instantiate spec49 * spec2.outerTest50 * spec2.innerTestA51 * spec3 = instantiate spec52 * spec3.outerTest53 * spec3.innerTestB54 */55@ExperimentalKotest56internal class InstancePerTestSpecRunner(57   listener: TestEngineListener,58   schedule: TestScheduler,59   private val defaultCoroutineDispatcherFactory: CoroutineDispatcherFactory,60   private val configuration: ProjectConfiguration,61) : SpecRunner(listener, schedule, configuration) {62   private val extensions = SpecExtensions(configuration.registry)63   private val results = ConcurrentHashMap<TestCase, TestResult>()64   /**65    * The intention of this runner is that each [TestCase] executes in its own instance66    * of the containing [Spec] class. Therefore, when we begin executing a test case from67    * the queue, we must first instantiate a new spec, and begin execution on _that_ instance.68    *69    * As test lambdas are executed, nested test cases will be registered, these should be ignored70    * if they are not an ancestor of the target. If they are then we can step into them, and71    * continue recursively until we find the target.72    *73    * Once the target is found it can be executed as normal, and any test lambdas it contains74    * can be registered back with the stack for execution later.75    */76   override suspend fun execute(spec: Spec): Result<Map<TestCase, TestResult>> =77      runCatching {78         launch(spec) {79            executeInCleanSpec(it)80               .getOrThrow()81         }82         results83      }84   /**85    * The intention of this runner is that each [TestCase] executes in its own instance86    * of the containing [Spec] class. Therefore, when we begin executing a test case from87    * the queue, we must first instantiate a new spec, and begin execution on _that_ instance.88    *89    * As test lambdas are executed, nested test cases will be registered, these should be ignored90    * if they are not an ancestor of the target. If they are then we can step into them, and91    * continue recursively until we find the target.92    *93    * Once the target is found it can be executed as normal, and any test lambdas it contains94    * can be registered back with the stack for execution later.95    */96   private suspend fun executeInCleanSpec(test: TestCase): Result<Spec> {97      return createInstance(test.spec::class)98         .flatMap { spec ->99            runCatching {100               extensions.intercept(spec) {101                  extensions.beforeSpec(spec)102                     .flatMap { run(it, test) }103                     .flatMap { extensions.afterSpec(it) }104               }105            }.map { spec }106         }107   }108   private suspend fun run(spec: Spec, test: TestCase): Result<Spec> = kotlin.runCatching {109      log { "Created new spec instance $spec" }110      // we need to find the same root test but in the newly created spec111      val root = materializer.materialize(spec).first { it.descriptor.isOnPath(test.descriptor) }112      log { "Starting root test ${root.descriptor} in search of ${test.descriptor}" }113      run(root, test)114      spec115   }116   private suspend fun run(test: TestCase, target: TestCase) {117      val isTarget = test.descriptor == target.descriptor118      coroutineScope {119         val context = object : TestScope {120            override val testCase: TestCase = test121            override val coroutineContext: CoroutineContext = this@coroutineScope.coroutineContext122            override suspend fun registerTestCase(nested: NestedTest) {123               val t = Materializer(configuration).materialize(nested, testCase)124               // if we are currently executing the target, then any registered tests are new, and we125               // should begin execution of them in fresh specs126               // otherwise if the test is on the path we can continue in the same spec127               if (isTarget) {128                  executeInCleanSpec(t).getOrThrow()129               } else if (t.descriptor.isOnPath(target.descriptor)) {130                  run(t, target)131               }132            }133         }134         val context2 = DuplicateNameHandlingTestScope(configuration.duplicateTestNameMode, context)135         val testExecutor = TestCaseExecutor(136            object : TestCaseExecutionListener {137               override suspend fun testStarted(testCase: TestCase) {138                  if (isTarget) listener.testStarted(testCase)139               }140               override suspend fun testIgnored(testCase: TestCase, reason: String?) {141                  if (isTarget) listener.testIgnored(testCase, reason)142               }143               override suspend fun testFinished(testCase: TestCase, result: TestResult) {144                  if (isTarget) listener.testFinished(testCase, result)145               }146            },147            defaultCoroutineDispatcherFactory,148            configuration...

SingleInstanceSpecRunner.kt

Source:SingleInstanceSpecRunner.kt

...14import 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

...6import io.kotest.core.test.TestCase7import io.kotest.core.test.TestResult8import 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               configuration...

scopes.kt

Source:scopes.kt

...31   listener: TestEngineListener,32   dispatcherFactory: CoroutineDispatcherFactory,33   configuration: ProjectConfiguration,34): TestScope {35   return DuplicateNameHandlingTestScope(36      testCase.spec.duplicateTestNameMode ?: configuration.duplicateTestNameMode,37      InOrderTestScope(38         testCase,39         coroutineContext,40         mode,41         listener,42         dispatcherFactory,43         configuration,44      )45   )46}...

DuplicateNameHandlingTestScope.kt

Source:DuplicateNameHandlingTestScope.kt

...6/**7 * Wraps a [TestScope] to add support for detecting duplicate test names in a scope, and handling8 * them via a [DuplicateTestNameHandler].9 */10class DuplicateNameHandlingTestScope(11   mode: DuplicateTestNameMode,12   private val delegate: TestScope13) : TestScope by delegate {14   private val handler = DuplicateTestNameHandler(mode)15   // in the single instance runner we execute each nested test as soon as they are registered16   override suspend fun registerTestCase(nested: NestedTest) {17      val withOverrideName = when (val uniqueName = handler.handle(nested.name)) {18         null -> nested19         else -> nested.copy(name = nested.name.copy(testName = uniqueName))20      }21      delegate.registerTestCase(withOverrideName)22   }23}...

DuplicateNameHandlingTestScope

Using AI Code Generation

1import io.kotest.core.spec.style.FunSpec2class DuplicateNameHandlingTestScopeTest : FunSpec() {3init {4context("DuplicateNameHandlingTestScope") {5test("should throw exception when duplicate test name is found") {6shouldThrow<IllegalArgumentException> {7DuplicateNameHandlingTestScope().test("test") {8}9DuplicateNameHandlingTestScope().test("test") {10}11}12}13}14}15}16import io.kotest.core.spec.style.FunSpec17class DuplicateNameHandlingTestScopeTest : FunSpec() {18init {19context("DuplicateNameHandlingTestScope") {20test("should throw exception when duplicate test name is found") {21shouldThrow<IllegalArgumentException> {22DuplicateNameHandlingTestScope().test("test") {23}24DuplicateNameHandlingTestScope().test("test") {25}26}27}28}29}30}31import io.kotest.core.spec.style.FunSpec32class DuplicateNameHandlingTestScopeTest : FunSpec() {33init {34context("DuplicateNameHandlingTestScope") {35test("should throw exception when duplicate test name is found") {36shouldThrow<IllegalArgumentException> {37DuplicateNameHandlingTestScope().test("test") {38}39DuplicateNameHandlingTestScope().test("test") {40}41}42}43}44}45}46import io.kotest.core.spec.style.FunSpec47class DuplicateNameHandlingTestScopeTest : FunSpec() {48init {49context("DuplicateNameHandlingTestScope") {50test("should throw exception when duplicate test name is found") {51shouldThrow<IllegalArgumentException> {52DuplicateNameHandlingTestScope().test("test") {53}54DuplicateNameHandlingTestScope().test("test") {55}56}57}58}59}60}61import io

DuplicateNameHandlingTestScope

Using AI Code Generation

1class DuplicateNameHandlingTestScopeTest : FunSpec({2   test("test case with same name and same config should fail") {3      val spec = object : FunSpec() {4         init {5            test("test case") {6            }7            test("test case") {8            }9         }10      }11      shouldThrow<IllegalArgumentException> {12         spec.testCases()13      }14   }15   test("test case with same name and different config should pass") {16      val spec = object : FunSpec() {17         init {18            test("test case") {19            }20            test("test case", tags = setOf(Tag("foo"))) {21            }22         }23      }24      spec.testCases().size shouldBe 225   }26   test("test case with same name and different config should pass") {27      val spec = object : FunSpec() {28         init {29            test("test case") {30            }31            test("test case", tags = setOf(Tag("foo"))) {32            }33         }34      }35      spec.testCases().size shouldBe 236   }37   test("test case with same name and different config should pass") {38      val spec = object : FunSpec() {39         init {40            test("test case") {41            }42            test("test case", tags = setOf(Tag("foo"))) {43            }44         }45      }46      spec.testCases().size shouldBe 247   }48   test("test case with same name and different config should pass") {49      val spec = object : FunSpec() {50         init {51            test("test case") {52            }53            test("test case", tags = setOf(Tag("foo"))) {54            }55         }56      }57      spec.testCases().size shouldBe 258   }59   test("test case with same name and different config should pass") {60      val spec = object : FunSpec() {61         init {62            test("test case") {63            }64            test("test case", tags = setOf(Tag("foo"))) {65            }66         }67      }68      spec.testCases().size shouldBe 269   }70   test("test case with same name and different config should pass") {71      val spec = object : FunSpec() {72         init {73            test("test case") {74            }75            test("test case", tags = setOf(Tag("foo"))) {76            }77         }78      }79      spec.testCases().size shouldBe 280   }

DuplicateNameHandlingTestScope

Using AI Code Generation

1val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")2scope.test("test name") {3}4scope.test("test name") {5}6val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")7scope.test("test name") {8}9scope.test("test name") {10}11val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")12scope.test("test name") {13}14scope.test("test name") {15}16val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")17scope.test("test name") {18}19scope.test("test name") {20}21val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")22scope.test("test name") {23}24scope.test("test name") {25}26val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")27scope.test("test name") {28}29scope.test("test name") {30}31val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")32scope.test("test name") {33}34scope.test("test name") {35}36val scope = DuplicateNameHandlingTestScope(DescriptorSpec::class, "test name")37scope.test("test name") {38}39scope.test("test name") {

DuplicateNameHandlingTestScope

Using AI Code Generation

1val testScope = DuplicateNameHandlingTestScope(context, test, false)2testScope.runTest()3val testScope = DuplicateNameHandlingTestScope(context, test, false)4testScope.runTest()5val testScope = DuplicateNameHandlingTestScope(context, test, false)6testScope.runTest()7val testScope = DuplicateNameHandlingTestScope(context, test, false)8testScope.runTest()9val testScope = DuplicateNameHandlingTestScope(context, test, false)10testScope.runTest()11val testScope = DuplicateNameHandlingTestScope(context, test, false)12testScope.runTest()13val testScope = DuplicateNameHandlingTestScope(context, test, false)14testScope.runTest()15val testScope = DuplicateNameHandlingTestScope(context, test, false)16testScope.runTest()17val testScope = DuplicateNameHandlingTestScope(context, test, false)18testScope.runTest()

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.