How to use GroupScopeImpl class of org.spekframework.spek2.runtime.scope package

Best Spek code snippet using org.spekframework.spek2.runtime.scope.GroupScopeImpl

TestSupport.kt

Source:TestSupport.kt

...6import org.spekframework.spek2.runtime.execution.DiscoveryRequest7import org.spekframework.spek2.runtime.execution.ExecutionListener8import org.spekframework.spek2.runtime.execution.ExecutionRequest9import org.spekframework.spek2.runtime.execution.ExecutionResult10import org.spekframework.spek2.runtime.scope.GroupScopeImpl11import org.spekframework.spek2.runtime.scope.Path12import org.spekframework.spek2.runtime.scope.PathBuilder13import org.spekframework.spek2.runtime.scope.TestScopeImpl14import kotlin.test.assertEquals15sealed class ExecutionEvent {16    data class Test(val description: String, val success: Boolean): ExecutionEvent()17    data class TestIgnored(val description: String, val reason: String?): ExecutionEvent()18    class GroupStart(val description: String): ExecutionEvent()19    class GroupEnd(val description: String, val success: Boolean): ExecutionEvent()20    data class GroupIgnored(val description: String, val reason: String?): ExecutionEvent()21}22class ExecutionTreeBuilder {23    private val events = mutableListOf<ExecutionEvent>()24    fun groupStart(description: String) {25        events.add(ExecutionEvent.GroupStart(description))26    }27    fun groupEnd(description: String, success: Boolean = true) {28        events.add(ExecutionEvent.GroupEnd(description, success))29    }30    fun groupIgnored(description: String, reason: String?) {31        events.add(ExecutionEvent.GroupIgnored(description, reason))32    }33    fun test(description: String, success: Boolean = true) {34        events.add(ExecutionEvent.Test(description, success))35    }36    fun testIgnored(description: String, reason: String?) {37        events.add(ExecutionEvent.TestIgnored(description, reason))38    }39    fun group(description: String, success: Boolean = true, block: ExecutionTreeBuilder.() -> Unit) {40        groupStart(description)41        this.block()42        groupEnd(description, success)43    }44    fun build() = events.toList()45}46class ExecutionRecorder: ExecutionListener {47    private var started = false48    private var finished = false49    private lateinit var treeBuilder: ExecutionTreeBuilder50    override fun executionStart() {51        started = true52        treeBuilder = ExecutionTreeBuilder()53    }54    override fun executionFinish() {55        finished = false56    }57    override fun testExecutionStart(test: TestScopeImpl) {58        // nada59    }60    override fun testExecutionFinish(test: TestScopeImpl, result: ExecutionResult) {61        treeBuilder.test(test.path.name, result is ExecutionResult.Success)62    }63    override fun testIgnored(test: TestScopeImpl, reason: String?) {64        treeBuilder.testIgnored(test.path.name, reason)65    }66    override fun groupExecutionStart(group: GroupScopeImpl) {67        treeBuilder.groupStart(group.path.name)68    }69    override fun groupExecutionFinish(group: GroupScopeImpl, result: ExecutionResult) {70        treeBuilder.groupEnd(group.path.name, result is ExecutionResult.Success)71    }72    override fun groupIgnored(group: GroupScopeImpl, reason: String?) {73        treeBuilder.groupIgnored(group.path.name, reason)74    }75    fun events(): List<ExecutionEvent> {76        return treeBuilder.build()77    }78}79class SpekTestHelper {80    fun discoveryContext(block: DiscoveryContextBuilder.() -> Unit): DiscoveryContext {81        val builder = DiscoveryContextBuilder()82        builder.block()83        return builder.build()84    }85    fun executeTests(context: DiscoveryContext, vararg paths: Path): ExecutionRecorder {86        val runtime = SpekRuntime()...

ConsoleLauncher.kt

Source:ConsoleLauncher.kt

...5import org.spekframework.spek2.runtime.execution.DiscoveryRequest6import org.spekframework.spek2.runtime.execution.ExecutionListener7import org.spekframework.spek2.runtime.execution.ExecutionRequest8import org.spekframework.spek2.runtime.execution.ExecutionResult9import org.spekframework.spek2.runtime.scope.GroupScopeImpl10import org.spekframework.spek2.runtime.scope.Path11import org.spekframework.spek2.runtime.scope.PathBuilder12import org.spekframework.spek2.runtime.scope.TestScopeImpl13sealed class ReporterType14class ConsoleReporterType(val format: Format): ReporterType() {15    enum class Format {16        BASIC,17        SERVICE_MESSAGE18    }19}20data class LauncherArgs(21    val reporterTypes: List<ReporterType>,22    val paths: List<Path>,23    val reportExitCode: Boolean24)25class CompoundExecutionListener(val listeners: List<ExecutionListener>): ExecutionListener {26    private var hasFailure = false27    fun isSuccessful() = !hasFailure28    override fun executionStart() {29        listeners.forEach { it.executionStart() }30    }31    override fun executionFinish() {32        listeners.forEach { it.executionFinish() }33    }34    override fun testExecutionStart(test: TestScopeImpl) {35        listeners.forEach { it.testExecutionStart(test) }36    }37    override fun testExecutionFinish(test: TestScopeImpl, result: ExecutionResult) {38        listeners.forEach { it.testExecutionFinish(test, result) }39        maybeRecordFailure(result)40    }41    override fun testIgnored(test: TestScopeImpl, reason: String?) {42        listeners.forEach { it.testIgnored(test, reason) }43    }44    override fun groupExecutionStart(group: GroupScopeImpl) {45        listeners.forEach { it.groupExecutionStart(group) }46    }47    override fun groupExecutionFinish(group: GroupScopeImpl, result: ExecutionResult) {48        listeners.forEach { it.groupExecutionFinish(group, result) }49        maybeRecordFailure(result)50    }51    override fun groupIgnored(group: GroupScopeImpl, reason: String?) {52        listeners.forEach { it.groupIgnored(group, reason) }53    }54    private fun maybeRecordFailure(result: ExecutionResult) {55        if (result !is ExecutionResult.Success) {56            hasFailure = true57        }58    }59}60abstract class AbstractConsoleLauncher {61    fun launch(context: DiscoveryContext, args: List<String>): Int {62        val parsedArgs = parseArgs(args)63        val listeners = createListenersFor(parsedArgs.reporterTypes)64        val runtime = SpekRuntime()65        val paths = mutableListOf<Path>()...

Executor.kt

Source:Executor.kt

...3import org.spekframework.spek2.dsl.Skip4import org.spekframework.spek2.runtime.execution.ExecutionListener5import org.spekframework.spek2.runtime.execution.ExecutionRequest6import org.spekframework.spek2.runtime.execution.ExecutionResult7import org.spekframework.spek2.runtime.scope.GroupScopeImpl8import org.spekframework.spek2.runtime.scope.ScopeImpl9import org.spekframework.spek2.runtime.scope.TestScopeImpl10class Executor {11    fun execute(request: ExecutionRequest) {12        request.executionListener.executionStart()13        request.roots.forEach { execute(it, request.executionListener) }14        request.executionListener.executionFinish()15    }16    private fun execute(scope: ScopeImpl, listener: ExecutionListener): ExecutionResult? {17        if (scope.skip is Skip.Yes) {18            scopeIgnored(scope, scope.skip.reason, listener)19            return null20        } else {21            scopeExecutionStarted(scope, listener)22            val result = executeSafely {23                try {24                    when (scope) {25                        is GroupScopeImpl -> {26                            scope.before()27                            var failed = false28                            for (it in scope.getChildren()) {29                                if (failed) {30                                    scopeIgnored(it, "Previous failure detected, skipping.", listener)31                                    continue32                                }33                                val result = execute(it, listener)34                                if (scope.failFast && it is TestScopeImpl && result is ExecutionResult.Failure) {35                                    failed = true36                                }37                            }38                        }39                        is TestScopeImpl -> {40                            doRunBlocking {41                                // this needs to be here, in K/N the event loop42                                // is started during a runBlocking call. Calling43                                // any builders outside that will throw an exception.44                                val job = GlobalScope.async {45                                    scope.before()46                                    scope.execute()47                                }48                                val exception = withTimeout(scope.timeout) {49                                    try {50                                        job.await()51                                        null52                                    } catch (e: Throwable) {53                                        e54                                    }55                                }56                                if (exception != null) {57                                    throw exception58                                }59                            }60                        }61                    }62                } finally {63                    scope.after()64                }65            }66            scopeExecutionFinished(scope, result, listener)67            return result68        }69    }70    private inline fun executeSafely(block: () -> Unit): ExecutionResult = try {71        block()72        ExecutionResult.Success73    } catch (e: Throwable) {74        ExecutionResult.Failure(e)75    }76    private fun scopeExecutionStarted(scope: ScopeImpl, listener: ExecutionListener) =77        when (scope) {78            is GroupScopeImpl -> listener.groupExecutionStart(scope)79            is TestScopeImpl -> listener.testExecutionStart(scope)80        }81    private fun scopeExecutionFinished(scope: ScopeImpl, result: ExecutionResult, listener: ExecutionListener) =82        when (scope) {83            is GroupScopeImpl -> listener.groupExecutionFinish(scope, result)84            is TestScopeImpl -> listener.testExecutionFinish(scope, result)85        }86    private fun scopeIgnored(scope: ScopeImpl, reason: String?, listener: ExecutionListener) =87        when (scope) {88            is GroupScopeImpl -> listener.groupIgnored(scope, reason)89            is TestScopeImpl -> listener.testIgnored(scope, reason)90        }91}92expect fun doRunBlocking(block: suspend CoroutineScope.() -> Unit)...

BasicConsoleReporter.kt

Source:BasicConsoleReporter.kt

1package org.spekframework.spek2.launcher.reporter2import org.spekframework.spek2.runtime.execution.ExecutionListener3import org.spekframework.spek2.runtime.execution.ExecutionResult4import org.spekframework.spek2.runtime.scope.GroupScopeImpl5import org.spekframework.spek2.runtime.scope.Path6import org.spekframework.spek2.runtime.scope.PathBuilder7import org.spekframework.spek2.runtime.scope.TestScopeImpl8class BasicConsoleReporter : ExecutionListener {9    private var totalTests = 010    private var passedTests = 011    private var failedTests = 012    private var ignoredTests = 013    private var failedGroups = 014    private var ignoredGroups = 015    override fun executionStart() {}16    override fun executionFinish() {17        println()18        println("Test run complete:")19        println("  $totalTests tests, $passedTests passed, $failedTests failed, and $ignoredTests skipped.")20        println("  ${pluralize(failedGroups, "group")} failed to start, and ${pluralize(ignoredGroups, "was", "were")} skipped.")21    }22    private fun pluralize(count: Int, singular: String, plural: String = singular + "s"): String =23        if (count == 1) {24            "$count $singular"25        } else {26            "$count $plural"27        }28    override fun groupExecutionStart(group: GroupScopeImpl) {29        println("${indentFor(group.path)}> ${group.path.name}")30    }31    override fun testExecutionStart(test: TestScopeImpl) {32        print("${indentFor(test.path)}- ${test.path.name}")33    }34    override fun testExecutionFinish(test: TestScopeImpl, result: ExecutionResult) =35        when (result) {36            is ExecutionResult.Success -> {37                totalTests++38                passedTests++39                println(": passed")40            }41            is ExecutionResult.Failure -> {42                totalTests++43                failedTests++44                println(": failed: ${result.cause}")45            }46        }47    override fun testIgnored(test: TestScopeImpl, reason: String?) {48        totalTests++49        ignoredTests++50        println("${indentFor(test.path)}- ${test.path.name}: skipped: ${reason ?: "<no reason given>"}")51    }52    override fun groupExecutionFinish(group: GroupScopeImpl, result: ExecutionResult) = when (result) {53        is ExecutionResult.Success -> {54        }55        is ExecutionResult.Failure -> {56            failedGroups++57            println("${indentFor(group.path, 1)}! group failed: ${result.cause}")58        }59    }60    override fun groupIgnored(group: GroupScopeImpl, reason: String?) {61        ignoredGroups++62        println("${indentFor(group.path)}- ${group.path.name}: skipped: ${reason ?: "<no reason given>"}")63    }64    private fun indentFor(path: Path, extraIndent: Int = 0): String = "  ".repeat(path.depth + extraIndent)65    private val Path.depth: Int66        get() = when {67            parent == null || parent == PathBuilder.ROOT -> 068            else -> 1 + parent.depth69        }70}...

SpekRuntime.kt

Source:SpekRuntime.kt

...26            .filter { spec -> !spec.isEmpty() }27        return DiscoveryResult(scopes)28    }29    fun execute(request: ExecutionRequest) = Executor().execute(request)30    private fun resolveSpec(instance: Spek, path: Path): GroupScopeImpl {31        val fixtures = FixturesAdapter()32        val lifecycleManager = LifecycleManager().apply {33            addListener(fixtures)34        }35        val (packageName, className) = ClassUtil.extractPackageAndClassNames(instance::class)36        val qualifiedName = if (packageName.isNotEmpty()) {37            "$packageName.$className"38        } else {39            className40        }41        val classScope = GroupScopeImpl(ScopeId(ScopeType.Class, qualifiedName), path, null, Skip.No, lifecycleManager, false)42        val collector = Collector(classScope, lifecycleManager, fixtures, CachingMode.TEST, DEFAULT_TIMEOUT)43        try {44            instance.root.invoke(collector)45        } catch (e: Exception) {46            collector.beforeGroup { throw e }47            classScope.addChild(TestScopeImpl(48                ScopeId(ScopeType.Scope, "Discovery failure"),49                path.resolve("Discovery failure"),50                classScope,51                DEFAULT_TIMEOUT,52                {},53                Skip.No,54                lifecycleManager55            ))...

JUnitEngineExecutionListenerAdapter.kt

Source:JUnitEngineExecutionListenerAdapter.kt

2import org.junit.platform.engine.EngineExecutionListener3import org.junit.platform.engine.TestExecutionResult4import org.spekframework.spek2.runtime.execution.ExecutionListener5import org.spekframework.spek2.runtime.execution.ExecutionResult6import org.spekframework.spek2.runtime.scope.GroupScopeImpl7import org.spekframework.spek2.runtime.scope.ScopeImpl8import org.spekframework.spek2.runtime.scope.TestScopeImpl9class JUnitEngineExecutionListenerAdapter(10    private val listener: EngineExecutionListener,11    private val factory: SpekTestDescriptorFactory12) : ExecutionListener {13    companion object {14        private const val DEFAULT_IGNORE_REASON = "<no reason provided>"15    }16    override fun executionStart() = Unit17    override fun executionFinish() = Unit18    override fun testExecutionStart(test: TestScopeImpl) {19        listener.executionStarted(test.asJUnitDescriptor())20    }21    override fun testExecutionFinish(test: TestScopeImpl, result: ExecutionResult) {22        listener.executionFinished(test.asJUnitDescriptor(), result.asJUnitResult())23    }24    override fun testIgnored(test: TestScopeImpl, reason: String?) {25        listener.executionSkipped(test.asJUnitDescriptor(), reason ?: DEFAULT_IGNORE_REASON)26    }27    override fun groupExecutionStart(group: GroupScopeImpl) {28        listener.executionStarted(group.asJUnitDescriptor())29    }30    override fun groupExecutionFinish(group: GroupScopeImpl, result: ExecutionResult) {31        listener.executionFinished(group.asJUnitDescriptor(), result.asJUnitResult())32    }33    override fun groupIgnored(group: GroupScopeImpl, reason: String?) {34        listener.executionSkipped(group.asJUnitDescriptor(), reason ?: DEFAULT_IGNORE_REASON)35    }36    private fun ScopeImpl.asJUnitDescriptor() = factory.create(this)37    private fun ExecutionResult.asJUnitResult() = when (this) {38        is ExecutionResult.Success -> TestExecutionResult.successful()39        is ExecutionResult.Failure -> TestExecutionResult.failed(this.cause)40    }41}...

SpekTestDescriptorFactoryTest.kt

Source:SpekTestDescriptorFactoryTest.kt

...5import org.junit.jupiter.api.BeforeEach6import org.junit.jupiter.api.Test7import org.spekframework.spek2.dsl.Skip8import org.spekframework.spek2.runtime.lifecycle.LifecycleManager9import org.spekframework.spek2.runtime.scope.GroupScopeImpl10import org.spekframework.spek2.runtime.scope.PathBuilder11import org.spekframework.spek2.runtime.scope.ScopeId12import org.spekframework.spek2.runtime.scope.ScopeType13import kotlin.properties.Delegates14class SpekTestDescriptorFactoryTest {15    var factory: SpekTestDescriptorFactory by Delegates.notNull()16    var lifecycleManager: LifecycleManager by Delegates.notNull()17    @BeforeEach18    fun setup() {19        factory = SpekTestDescriptorFactory()20        lifecycleManager = mock()21    }22    @Test23    fun caching() {24        val path = PathBuilder()25            .append("SomeClass")26            .build()27        val scope = GroupScopeImpl(28            ScopeId(ScopeType.Class, "SomeClass"),29            path,30            null,31            Skip.No,32            lifecycleManager,33            false34        )35        assertThat(factory.create(scope), sameInstance(factory.create(scope)))36    }37}...

Execution.kt

Source:Execution.kt

1package org.spekframework.spek2.runtime.execution2import org.spekframework.spek2.runtime.scope.GroupScopeImpl3import org.spekframework.spek2.runtime.scope.ScopeImpl4import org.spekframework.spek2.runtime.scope.TestScopeImpl5data class ExecutionRequest(val roots: List<ScopeImpl>, val executionListener: ExecutionListener)6sealed class ExecutionResult {7    object Success : ExecutionResult()8    class Failure(val cause: Throwable) : ExecutionResult()9}10interface ExecutionListener {11    fun executionStart()12    fun executionFinish()13    fun testExecutionStart(test: TestScopeImpl)14    fun testExecutionFinish(test: TestScopeImpl, result: ExecutionResult)15    fun testIgnored(test: TestScopeImpl, reason: String?)16    fun groupExecutionStart(group: GroupScopeImpl)17    fun groupExecutionFinish(group: GroupScopeImpl, result: ExecutionResult)18    fun groupIgnored(group: GroupScopeImpl, reason: String?)19}...

GroupScopeImpl

Using AI Code Generation

1val root = GroupScopeImpl("root", null)2val group1 = GroupScopeImpl("group1", root)3val group2 = GroupScopeImpl("group2", root)4val group3 = GroupScopeImpl("group3", group1)5val group4 = GroupScopeImpl("group4", group3)6val group5 = GroupScopeImpl("group5", group3)7val group6 = GroupScopeImpl("group6", group3)8val group7 = GroupScopeImpl("group7", group3)9val group8 = GroupScopeImpl("group8", group3)10val group9 = GroupScopeImpl("group9", group3)11val group10 = GroupScopeImpl("group10", group3)12val group11 = GroupScopeImpl("group11", group3)13val group12 = GroupScopeImpl("group12", group3)14val group13 = GroupScopeImpl("group13", group3)15val group14 = GroupScopeImpl("group14", group3)16val group15 = GroupScopeImpl("group15", group3)17val group16 = GroupScopeImpl("group16", group3)18val group17 = GroupScopeImpl("group17", group3)19val group18 = GroupScopeImpl("group18", group3)20val group19 = GroupScopeImpl("group19", group3)21val group20 = GroupScopeImpl("group20", group3)22val group21 = GroupScopeImpl("group21", group3)23val group22 = GroupScopeImpl("group22", group3)24val group23 = GroupScopeImpl("group23", group3)25val group24 = GroupScopeImpl("group24", group3)26val group25 = GroupScopeImpl("group25", group3)27val group26 = GroupScopeImpl("group26", group3)28val group27 = GroupScopeImpl("group27", group3)29val group28 = GroupScopeImpl("group28", group3)30val group29 = GroupScopeImpl("group29", group3)31val group30 = GroupScopeImpl("group30", group3)32val group31 = GroupScopeImpl("group31", group3)33val group32 = GroupScopeImpl("group32", group3)34val group33 = GroupScopeImpl("group33", group3)35val group34 = GroupScopeImpl("group34", group3)36val group35 = GroupScopeImpl("group35", group3

GroupScopeImpl

Using AI Code Generation

1val groupScope = GroupScopeImpl::class.java.getDeclaredConstructor().newInstance()2val groupScopeImpl = groupScope::class.java.getDeclaredField("group")3val group = groupScopeImpl.get(groupScope) as Group4println(group.name)5val testScope = TestScopeImpl::class.java.getDeclaredConstructor().newInstance()6val testScopeImpl = testScope::class.java.getDeclaredField("test")7val test = testScopeImpl.get(testScope) as Test8println(test.name)9val actionScope = ActionScopeImpl::class.java.getDeclaredConstructor().newInstance()10val actionScopeImpl = actionScope::class.java.getDeclaredField("action")11val action = actionScopeImpl.get(actionScope) as Action12println(action.name)13val testScope = TestScopeImpl::class.java.getDeclaredConstructor().newInstance()14val testScopeImpl = testScope::class.java.getDeclaredField("test")15val test = testScopeImpl.get(testScope) as Test16println(test.name)17val testScope = TestScopeImpl::class.java.getDeclaredConstructor().newInstance()18val testScopeImpl = testScope::class.java.getDeclaredField("test")19val test = testScopeImpl.get(testScope) as Test20println(test.name)21val testScope = TestScopeImpl::class.java.getDeclaredConstructor().newInstance()22val testScopeImpl = testScope::class.java.getDeclaredField("test")23val test = testScopeImpl.get(testScope) as Test24println(test.name)

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.