How to use LifecycleManager class of org.spekframework.spek2.runtime.lifecycle package

Best Spek code snippet using org.spekframework.spek2.runtime.lifecycle.LifecycleManager

Collectors.kt

Source:Collectors.kt

2import org.spekframework.spek2.dsl.*3import org.spekframework.spek2.lifecycle.CachingMode4import org.spekframework.spek2.lifecycle.LifecycleListener5import org.spekframework.spek2.lifecycle.MemoizedValue6import org.spekframework.spek2.runtime.lifecycle.LifecycleManager7import org.spekframework.spek2.runtime.lifecycle.MemoizedValueCreator8import org.spekframework.spek2.runtime.lifecycle.MemoizedValueReader9import org.spekframework.spek2.runtime.scope.*10class Collector(11    val root: GroupScopeImpl,12    private val lifecycleManager: LifecycleManager,13    private val fixtures: FixturesAdapter,14    override val defaultCachingMode: CachingMode,15    override var defaultTimeout: Long16) : Root {17    private val ids = linkedMapOf<String, Int>()18    override fun <T> memoized(mode: CachingMode, factory: () -> T): MemoizedValue<T> = memoized(mode, factory) { }19    override fun <T> memoized(mode: CachingMode, factory: () -> T, destructor: (T) -> Unit): MemoizedValue<T> {20        return MemoizedValueCreator(21            root,22            mode,23            factory,24            destructor25        )26    }...

Scopes.kt

Source:Scopes.kt

...4import org.spekframework.spek2.lifecycle.GroupScope5import org.spekframework.spek2.lifecycle.MemoizedValue6import org.spekframework.spek2.lifecycle.Scope7import org.spekframework.spek2.lifecycle.TestScope8import org.spekframework.spek2.runtime.lifecycle.LifecycleManager9import org.spekframework.spek2.runtime.lifecycle.MemoizedValueReader10import kotlin.properties.ReadOnlyProperty11sealed class ScopeImpl(12    val id: ScopeId,13    val path: Path,14    val skip: Skip,15    val lifecycleManager: LifecycleManager16) : Scope {17    private val values = mutableMapOf<String, ReadOnlyProperty<Any?, Any?>>()18    abstract fun before()19    abstract fun execute()20    abstract fun after()21    fun registerValue(name: String, value: ReadOnlyProperty<Any?, Any?>) {22        values[name] = value23    }24    fun getValue(name: String): ReadOnlyProperty<Any?, Any?> = when {25        values.containsKey(name) -> values[name]!!26        parent != null -> (parent as ScopeImpl).getValue(name)27        else -> throw IllegalArgumentException("No value for '$name'")28    }29}30open class GroupScopeImpl(31    id: ScopeId,32    path: Path,33    override val parent: GroupScope?,34    skip: Skip,35    lifecycleManager: LifecycleManager,36    preserveExecutionOrder: Boolean,37    val failFast: Boolean = false38) : ScopeImpl(id, path, skip, lifecycleManager), GroupScope {39    private val children = mutableListOf<ScopeImpl>()40    fun addChild(child: ScopeImpl) {41        children.add(child)42    }43    fun removeChild(child: ScopeImpl) {44        children.remove(child)45    }46    fun getChildren() = children.toList()47    fun filterBy(path: Path) {48        val filteredChildren = children49            .filter { it.path.intersects(path) }50            .map {51                if (it is GroupScopeImpl) {52                    it.filterBy(path)53                }54                it55            }56        children.clear()57        children.addAll(filteredChildren)58    }59    fun isEmpty() = children.isEmpty()60    override fun before() = lifecycleManager.beforeExecuteGroup(this)61    override fun execute() = Unit62    override fun after() = lifecycleManager.afterExecuteGroup(this)63}64class TestScopeImpl(65    id: ScopeId,66    path: Path,67    override val parent: GroupScope,68    val timeout: Long,69    private val body: TestBody.() -> Unit,70    skip: Skip,71    lifecycleManager: LifecycleManager72) : ScopeImpl(id, path, skip, lifecycleManager), TestScope {73    override fun before() = lifecycleManager.beforeExecuteTest(this)74    override fun execute() {75        body.invoke(object : TestBody {76            override fun <T> memoized(): MemoizedValue<T> {77                return MemoizedValueReader(this@TestScopeImpl)78            }79        })80    }81    override fun after() = lifecycleManager.afterExecuteTest(this)82}...

SpekRuntime.kt

Source:SpekRuntime.kt

...4import org.spekframework.spek2.lifecycle.CachingMode5import org.spekframework.spek2.runtime.execution.DiscoveryRequest6import org.spekframework.spek2.runtime.execution.DiscoveryResult7import org.spekframework.spek2.runtime.execution.ExecutionRequest8import org.spekframework.spek2.runtime.lifecycle.LifecycleManager9import org.spekframework.spek2.runtime.scope.*10import org.spekframework.spek2.runtime.util.ClassUtil11private const val DEFAULT_TIMEOUT = 10000L12class SpekRuntime {13    fun discover(discoveryRequest: DiscoveryRequest): DiscoveryResult {14        val scopes = discoveryRequest.context.getTests()15            .map { testInfo ->16                val matchingPath = discoveryRequest.paths.firstOrNull { it.intersects(testInfo.path) }17                testInfo to matchingPath18            }19            .filter { (_, matchingPath) -> matchingPath != null }20            .map { (testInfo, matchingPath) ->21                checkNotNull(matchingPath)22                val spec = resolveSpec(testInfo.createInstance(), testInfo.path)23                spec.filterBy(matchingPath)24                spec25            }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 }...

MemoizedValueCreator.kt

Source:MemoizedValueCreator.kt

1package org.spekframework.spek2.runtime.lifecycle2import org.spekframework.spek2.lifecycle.CachingMode3import org.spekframework.spek2.lifecycle.MemoizedValue4import org.spekframework.spek2.runtime.scope.ScopeImpl5import kotlin.properties.ReadOnlyProperty6import kotlin.reflect.KProperty7class MemoizedValueCreator<out T>(8    val scope: ScopeImpl,9    private val mode: CachingMode,10    val factory: () -> T,11    private val destructor: (T) -> Unit12) : MemoizedValue<T> {13    override operator fun provideDelegate(14        thisRef: Any?,15        property: KProperty<*>16    ): ReadOnlyProperty<Any?, T> {17        val adapter = when (mode) {18            CachingMode.GROUP, CachingMode.EACH_GROUP -> MemoizedValueAdapter.GroupCachingModeAdapter(factory, destructor)19            CachingMode.TEST -> MemoizedValueAdapter.TestCachingModeAdapter(factory, destructor)20            CachingMode.SCOPE -> MemoizedValueAdapter.ScopeCachingModeAdapter(scope, factory, destructor)21            CachingMode.INHERIT -> throw AssertionError("Not allowed.")22        }23        // reserve name24        scope.registerValue(property.name, adapter)25        return adapter.apply {26            scope.lifecycleManager.addListener(this)27        }28    }29}30class MemoizedValueReader<out T>(val scope: ScopeImpl) : MemoizedValue<T> {31    @Suppress("UNCHECKED_CAST")32    override operator fun provideDelegate(33        thisRef: Any?,34        property: KProperty<*>35    ): ReadOnlyProperty<Any?, T> {36        return scope.getValue(property.name) as ReadOnlyProperty<Any?, T>37    }38}...

SpekTestDescriptorFactoryTest.kt

Source:SpekTestDescriptorFactoryTest.kt

...4import com.nhaarman.mockitokotlin2.mock5import 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,...

LifecycleManager.kt

Source:LifecycleManager.kt

1package org.spekframework.spek2.runtime.lifecycle2import org.spekframework.spek2.lifecycle.GroupScope3import org.spekframework.spek2.lifecycle.LifecycleListener4import org.spekframework.spek2.lifecycle.TestScope5class LifecycleManager {6    private val listeners = mutableListOf<LifecycleListener>()7    fun addListener(listener: LifecycleListener) {8        if (listeners.contains(listener)) {9            throw IllegalArgumentException("You can only register a listener once.")10        }11        listeners.add(0, listener)12    }13    fun beforeExecuteTest(test: TestScope) {14        listeners.forEach { it.beforeExecuteTest(test) }15    }16    fun afterExecuteTest(test: TestScope) {17        listeners.reversed().forEach { it.afterExecuteTest(test) }18    }19    fun beforeExecuteGroup(group: GroupScope) {...

LifecycleManager

Using AI Code Generation

1val lifecycleManager = LifecycleManager()2lifecycleManager.beforeGroup { println( "beforeGroup" ) }3lifecycleManager.afterGroup { println( "afterGroup" ) }4lifecycleManager.beforeTest { println( "beforeTest" ) }5lifecycleManager.afterTest { println( "afterTest" ) }6lifecycleManager.beforeExecuteTest { println( "beforeExecuteTest" ) }7lifecycleManager.afterExecuteTest { println( "afterExecuteTest" ) }8lifecycleManager.beforeExecuteAction { println( "beforeExecuteAction" ) }9lifecycleManager.afterExecuteAction { println( "afterExecuteAction" ) }10val lifecycleAware = object : LifecycleAware {11override fun beforeGroup() {12println( "beforeGroup" )13}14override fun afterGroup() {15println( "afterGroup" )16}17override fun beforeTest() {18println( "beforeTest" )19}20override fun afterTest() {21println( "afterTest" )22}23override fun beforeExecuteTest() {24println( "beforeExecuteTest" )25}26override fun afterExecuteTest() {27println( "afterExecuteTest" )28}29override fun beforeExecuteAction() {30println( "beforeExecuteAction" )31}32override fun afterExecuteAction() {33println( "afterExecuteAction" )34}35}36val lifecycleListener = object : LifecycleListener {37override fun beforeGroup(testPath: TestPath) {38println( "beforeGroup" )39}40override fun afterGroup(testPath: TestPath) {41println( "afterGroup" )42}43override fun beforeTest(testPath: TestPath) {44println( "beforeTest" )45}46override fun afterTest(testPath: TestPath) {47println( "afterTest" )48}49override fun beforeExecuteTest(testPath: TestPath) {50println( "beforeExecuteTest" )51}52override fun afterExecuteTest(testPath: TestPath) {53println( "afterExecuteTest" )54}55override fun beforeExecuteAction(testPath: TestPath) {56println( "beforeExecuteAction" )57}58override fun afterExecuteAction(testPath: TestPath) {59println( "afterExecuteAction" )60}61}62val lifecycleManagerAdapter = object : LifecycleManagerAdapter() {

LifecycleManager

Using AI Code Generation

1val listener = object : LifecycleListener {2override fun afterExecuteTest(test: TestScope) {3println("afterExecuteTest: ${test.path}")4}5override fun afterExecuteGroup(group: GroupScope) {6println("afterExecuteGroup: ${group.path}")7}8override fun beforeExecuteTest(test: TestScope) {9println("beforeExecuteTest: ${test.path}")10}11override fun beforeExecuteGroup(group: GroupScope) {12println("beforeExecuteGroup: ${group.path}")13}14}15LifecycleManager.registerListener(listener)16LifecycleManager.unregisterListener(listener)

LifecycleManager

Using AI Code Generation

1import org.spekframework.spek2.runtime.lifecycle.LifecycleManager2val lifecycleManager = LifecycleManager()3lifecycleManager.execute(SpekTest::class.java)4val lifecycleManager = LifecycleManager()5lifecycleManager.execute(SpekTest::class.java)6import org.spekframework.spek2.runtime.lifecycle.LifecycleManager7val lifecycleManager = LifecycleManager()8lifecycleManager.execute(SpekTest::class.java)9val lifecycleManager = LifecycleManager()10lifecycleManager.execute(SpekTest::class.java)11import org.spekframework.spek2.runtime.lifecycle.LifecycleManager12val lifecycleManager = LifecycleManager()13lifecycleManager.execute(SpekTest::class.java)14val lifecycleManager = LifecycleManager()15lifecycleManager.execute(SpekTest::class.java)16import org.spekframework.spek2.runtime.lifecycle.LifecycleManager17val lifecycleManager = LifecycleManager()18lifecycleManager.execute(SpekTest::class.java)19val lifecycleManager = LifecycleManager()20lifecycleManager.execute(SpekTest::class.java)

LifecycleManager

Using AI Code Generation

1    LifecycleManager.runTests(this::class)2}3class MySpekTest: Spek({4    SpekRuntime.runTests(this::class)5})6class MySpekTest: Spek({7    JUnitPlatform.runTests(this::class)8})9class MySpekTest: Spek({10    JUnitPlatform.runTests(this::class)11})12class MySpekTest: Spek({13    JUnitPlatform.runTests(this::class)14})

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.