How to use Spec.functionOverrideCallbacks method of io.kotest.core.spec.listeners class

Best Kotest code snippet using io.kotest.core.spec.listeners.Spec.functionOverrideCallbacks

SpecExtensions.kt

Source:SpecExtensions.kt

1package io.kotest.engine.spec2import io.kotest.common.mapError3import io.kotest.core.config.ExtensionRegistry4import io.kotest.core.extensions.Extension5import io.kotest.core.extensions.SpecExtension6import io.kotest.core.listeners.AfterSpecListener7import io.kotest.core.listeners.BeforeSpecListener8import io.kotest.core.listeners.FinalizeSpecListener9import io.kotest.core.listeners.IgnoredSpecListener10import io.kotest.core.listeners.InstantiationErrorListener11import io.kotest.core.listeners.InstantiationListener12import io.kotest.core.listeners.PrepareSpecListener13import io.kotest.core.listeners.SpecInstantiationListener14import io.kotest.core.spec.Spec15import io.kotest.core.spec.functionOverrideCallbacks16import io.kotest.core.test.TestCase17import io.kotest.core.test.TestResult18import io.kotest.engine.extensions.ExtensionException19import io.kotest.engine.extensions.MultipleExceptions20import io.kotest.mpp.Logger21import io.kotest.mpp.bestName22import kotlin.reflect.KClass23/**24 * Used to invoke extension points / listeners / callbacks on specs.25 */26internal class SpecExtensions(private val registry: ExtensionRegistry) {27   private val logger = Logger(SpecExtensions::class)28   /**29    * Returns all [Extension]s applicable to a [Spec]. This includes extensions via30    * function overrides, those registered explicitly in the spec as part of the DSL,31    * and project wide extensions from configuration.32    */33   fun extensions(spec: Spec): List<Extension> {34      return spec.extensions() + // overriding the extensions function in the spec35         spec.listeners() + // overriding the listeners function in the spec36         spec.functionOverrideCallbacks() + // dsl37         spec.registeredExtensions() + // added to the spec via register38         registry.all() // globals39   }40   suspend fun beforeSpec(spec: Spec): Result<Spec> {41      logger.log { Pair(spec::class.bestName(), "beforeSpec $spec") }42      val errors = extensions(spec).filterIsInstance<BeforeSpecListener>().mapNotNull { ext ->43         runCatching { ext.beforeSpec(spec) }44            .mapError { ExtensionException.BeforeSpecException(it) }.exceptionOrNull()45      }46      return when {47         errors.isEmpty() -> Result.success(spec)48         errors.size == 1 -> Result.failure(errors.first())49         else -> Result.failure(MultipleExceptions(errors))50      }51   }52   /**53    * Runs all the after spec listeners for this [Spec]. All errors are caught and wrapped54    * in [AfterSpecListener] and if more than one error, all will be returned as a [MultipleExceptions].55    */56   suspend fun afterSpec(spec: Spec): Result<Spec> = runCatching {57      logger.log { Pair(spec::class.bestName(), "afterSpec $spec") }58      spec.registeredAutoCloseables().let { closeables ->59         logger.log { Pair(spec::class.bestName(), "Closing ${closeables.size} autocloseables [$closeables]") }60         closeables.forEach {61            if(it.isInitialized()) it.value.close() else Unit62         }63      }64      val errors = extensions(spec).filterIsInstance<AfterSpecListener>().mapNotNull { ext ->65         runCatching { ext.afterSpec(spec) }66            .mapError { ExtensionException.AfterSpecException(it) }.exceptionOrNull()67      }68      return when {69         errors.isEmpty() -> Result.success(spec)70         errors.size == 1 -> Result.failure(errors.first())71         else -> Result.failure(MultipleExceptions(errors))72      }73   }74   suspend fun specInstantiated(spec: Spec) = runCatching {75      logger.log { Pair(spec::class.bestName(), "specInstantiated $spec") }76      registry.all().filterIsInstance<SpecInstantiationListener>().forEach { it.specInstantiated(spec) }77      registry.all().filterIsInstance<InstantiationListener>().forEach { it.specInstantiated(spec) }78   }79   suspend fun specInstantiationError(kclass: KClass<out Spec>, t: Throwable) = runCatching {80      logger.log { Pair(kclass.bestName(), "specInstantiationError $t") }81      registry.all().filterIsInstance<SpecInstantiationListener>().forEach { it.specInstantiationError(kclass, t) }82      registry.all().filterIsInstance<InstantiationErrorListener>().forEach { it.instantiationError(kclass, t) }83   }84   suspend fun prepareSpec(kclass: KClass<out Spec>): Result<KClass<*>> {85      val exts = registry.all().filterIsInstance<PrepareSpecListener>()86      logger.log { Pair(kclass.bestName(), "prepareSpec (${exts.size})") }87      val errors = exts.mapNotNull {88         runCatching { it.prepareSpec(kclass) }89            .mapError { ExtensionException.PrepareSpecException(it) }.exceptionOrNull()90      }91      return when {92         errors.isEmpty() -> Result.success(kclass)93         errors.size == 1 -> Result.failure(errors.first())94         else -> Result.failure(MultipleExceptions(errors))95      }96   }97   suspend fun finalizeSpec(98      kclass: KClass<out Spec>,99      results: Map<TestCase, TestResult>,100      t: Throwable?101   ): Result<KClass<out Spec>> {102      val exts = registry.all().filterIsInstance<FinalizeSpecListener>()103      logger.log { Pair(kclass.bestName(), "finishSpec (${exts.size}) results:$results") }104      val errors = exts.mapNotNull {105         runCatching { it.finalizeSpec(kclass, results) }106            .mapError { ExtensionException.FinalizeSpecException(it) }.exceptionOrNull()107      }108      return when {109         errors.isEmpty() -> Result.success(kclass)110         errors.size == 1 -> Result.failure(errors.first())111         else -> Result.failure(MultipleExceptions(errors))112      }113   }114   suspend fun <T> intercept(spec: Spec, f: suspend () -> T): T? {115      val exts = extensions(spec).filterIsInstance<SpecExtension>()116      logger.log { Pair(spec::class.bestName(), "Intercepting spec with ${exts.size} spec extensions") }117      var result: T? = null118      val initial: suspend () -> Unit = {119         result = f()120      }121      val chain = exts.foldRight(initial) { op, acc ->122         {123            op.intercept(spec::class) {124               op.intercept(spec) {125                  acc()126               }127            }128         }129      }130      chain.invoke()131      return result132   }133   /**134    * Notify all [IgnoredSpecListener]s that the given [kclass] has been ignored.135    */136   suspend fun ignored(kclass: KClass<out Spec>, reason: String?): Result<KClass<out Spec>> {137      val exts = registry.all().filterIsInstance<IgnoredSpecListener>()138      logger.log { Pair(kclass.bestName(), "ignored ${exts.size} extensions on $kclass") }139      val errors = exts.mapNotNull {140         runCatching { it.ignoredSpec(kclass, reason) }141            .mapError { ExtensionException.IgnoredSpecException(it) }.exceptionOrNull()142      }143      return when {144         errors.isEmpty() -> Result.success(kclass)145         errors.size == 1 -> Result.failure(errors.first())146         else -> Result.failure(MultipleExceptions(errors))147      }148   }149}...

TestExtensions.kt

Source:TestExtensions.kt

1package io.kotest.engine.test2import io.kotest.common.collect3import io.kotest.common.mapError4import io.kotest.core.config.ExtensionRegistry5import io.kotest.core.extensions.Extension6import io.kotest.core.extensions.TestCaseExtension7import io.kotest.core.listeners.AfterContainerListener8import io.kotest.core.listeners.AfterEachListener9import io.kotest.core.listeners.AfterInvocationListener10import io.kotest.core.listeners.AfterTestListener11import io.kotest.core.listeners.BeforeContainerListener12import io.kotest.core.listeners.BeforeEachListener13import io.kotest.core.listeners.BeforeInvocationListener14import io.kotest.core.listeners.BeforeTestListener15import io.kotest.core.spec.functionOverrideCallbacks16import io.kotest.core.test.TestCase17import io.kotest.core.test.TestResult18import io.kotest.core.test.TestScope19import io.kotest.core.test.TestType20import io.kotest.engine.extensions.ExtensionException21import io.kotest.engine.extensions.MultipleExceptions22import io.kotest.engine.test.logging.LogExtension23import io.kotest.engine.test.scopes.withCoroutineContext24import kotlin.coroutines.coroutineContext25/**26 * Used to invoke extension points on tests.27 */28internal class TestExtensions(private val registry: ExtensionRegistry) {29   /**30    * Returns all [Extension]s applicable to a [TestCase]. This includes extensions31    * included in test case config, those at the spec level, and project wide from32    * the registry.33    */34   fun extensions(testCase: TestCase): List<Extension> {35      return testCase.config.extensions +36         testCase.spec.extensions() + // overriding the extensions function in the spec37         testCase.spec.listeners() + // overriding the listeners function in the spec38         testCase.spec.functionOverrideCallbacks() + // spec level dsl eg beforeTest { }39         testCase.spec.registeredExtensions() + // added to the spec via register40         registry.all() // globals41   }42   suspend fun beforeInvocation(testCase: TestCase, invocation: Int): Result<TestCase> {43      val extensions = extensions(testCase).filterIsInstance<BeforeInvocationListener>()44      return extensions.map {45         runCatching {46            it.beforeInvocation(testCase, invocation)47         }.mapError { ExtensionException.BeforeInvocationException(it) }48      }.collect { if (it.size == 1) it.first() else MultipleExceptions(it) }.map { testCase }49   }50   suspend fun afterInvocation(testCase: TestCase, invocation: Int): Result<TestCase> {51      val extensions = extensions(testCase).filterIsInstance<AfterInvocationListener>()52      return extensions.map {53         runCatching {54            it.afterInvocation(testCase, invocation)55         }.mapError { ExtensionException.AfterInvocationException(it) }56      }.collect { if (it.size == 1) it.first() else MultipleExceptions(it) }.map { testCase }57   }58   /**59    * Invokes all beforeXYZ callbacks for this test, checking for the appropriate test type.60    * Returns a Result of [MultipleExceptions] if there are any exceptions.61    */62   suspend fun beforeTestBeforeAnyBeforeContainer(testCase: TestCase): Result<TestCase> {63      val bt = extensions(testCase).filterIsInstance<BeforeTestListener>()64      val bc = extensions(testCase).filterIsInstance<BeforeContainerListener>()65      val be = extensions(testCase).filterIsInstance<BeforeEachListener>()66      val errors = bc.mapNotNull {67         runCatching {68            if (testCase.type == TestType.Container) it.beforeContainer(testCase)69         }.mapError { ExtensionException.BeforeContainerException(it) }.exceptionOrNull()70      } + be.mapNotNull {71         runCatching {72            if (testCase.type == TestType.Test) it.beforeEach(testCase)73         }.mapError { ExtensionException.BeforeEachException(it) }.exceptionOrNull()74      } + bt.mapNotNull {75         runCatching {76            it.beforeAny(testCase)77         }.mapError { ExtensionException.BeforeAnyException(it) }.exceptionOrNull()78      } + bt.mapNotNull {79         runCatching {80            it.beforeTest(testCase)81         }.mapError { ExtensionException.BeforeTestException(it) }.exceptionOrNull()82      }83      return when {84         errors.isEmpty() -> Result.success(testCase)85         errors.size == 1 -> Result.failure(errors.first())86         else -> Result.failure(MultipleExceptions(errors))87      }88   }89   /**90    * Invokes all beforeXYZ callbacks for this test.91    * Returns a Result of [MultipleExceptions] if there are any exceptions.92    */93   suspend fun afterTestAfterAnyAfterContainer(testCase: TestCase, result: TestResult): Result<TestResult> {94      val at = extensions(testCase).filterIsInstance<AfterTestListener>()95      val ac = extensions(testCase).filterIsInstance<AfterContainerListener>()96      val ae = extensions(testCase).filterIsInstance<AfterEachListener>()97      val errors = at.mapNotNull {98         runCatching {99            it.afterTest(testCase, result)100         }.mapError { ExtensionException.AfterTestException(it) }.exceptionOrNull()101      } + at.mapNotNull {102         runCatching {103            it.afterAny(testCase, result)104         }.mapError { ExtensionException.AfterAnyException(it) }.exceptionOrNull()105      } + ac.mapNotNull {106         runCatching {107            if (testCase.type == TestType.Container) it.afterContainer(testCase, result)108         }.mapError { ExtensionException.AfterContainerException(it) }.exceptionOrNull()109      } + ae.mapNotNull {110         runCatching {111            if (testCase.type == TestType.Test) it.afterEach(testCase, result)112         }.mapError { ExtensionException.AfterEachException(it) }.exceptionOrNull()113      }114      return when {115         errors.isEmpty() -> Result.success(result)116         errors.size == 1 -> Result.failure(errors.first())117         else -> Result.failure(MultipleExceptions(errors))118      }119   }120   /**121    * Executes the [TestCaseExtension]s for this [TestCase].122    */123   suspend fun intercept(124      testCase: TestCase,125      context: TestScope,126      inner: suspend (TestCase, TestScope) -> TestResult,127   ): TestResult {128      val execute = extensions(testCase).filterIsInstance<TestCaseExtension>()129         .foldRight(inner) { extension, execute ->130            { tc, ctx ->131               extension.intercept(tc) {132                  // the user's intercept method is free to change the context of the coroutine133                  // to support this, we should switch the context used by the test case context134                  execute(it, ctx.withCoroutineContext(coroutineContext))135               }136            }137         }138      return execute(testCase, context)139   }140   fun logExtensions(testCase: TestCase): List<LogExtension> {141      return extensions(testCase).filterIsInstance<LogExtension>()142   }143}...

listeners.kt

Source:listeners.kt

1package io.kotest.core.spec2import io.kotest.core.listeners.TestListener3import io.kotest.core.test.TestCase4import io.kotest.core.test.TestResult5/**6 * Returns a [TestListener] which passes lifecycle events through to the appropriate7 * spec member function.8 */9fun Spec.functionOverrideCallbacks() = object : TestListener {10   override suspend fun afterSpec(spec: Spec) {11      this@functionOverrideCallbacks.afterSpec(spec)12   }13   override suspend fun beforeSpec(spec: Spec) {14      this@functionOverrideCallbacks.beforeSpec(spec)15   }16   override suspend fun afterTest(testCase: TestCase, result: TestResult) {17      this@functionOverrideCallbacks.afterTest(testCase, result)18   }19   override suspend fun beforeTest(testCase: TestCase) {20      this@functionOverrideCallbacks.beforeTest(testCase)21   }22   override suspend fun afterContainer(testCase: TestCase, result: TestResult) {23      this@functionOverrideCallbacks.afterContainer(testCase, result)24   }25   override suspend fun beforeContainer(testCase: TestCase) {26      this@functionOverrideCallbacks.beforeContainer(testCase)27   }28   override suspend fun afterEach(testCase: TestCase, result: TestResult) {29      this@functionOverrideCallbacks.afterEach(testCase, result)30   }31   override suspend fun beforeEach(testCase: TestCase) {32      this@functionOverrideCallbacks.beforeEach(testCase)33   }34   override suspend fun afterAny(testCase: TestCase, result: TestResult) {35      this@functionOverrideCallbacks.afterAny(testCase, result)36   }37   override suspend fun beforeAny(testCase: TestCase) {38      this@functionOverrideCallbacks.beforeAny(testCase)39   }40}...