I'm trying to decipher how

AbstractProjectConfig

works in Kotlin/Js (in a standard multiplatform configuration using Karma). My preliminary findings suggest that a

BeforeProjectListener

extension works as expected while a `ProjectExtension`'s

interceptProject

method is not being invoked. Are there any known limitations? Also, what are the entry points into the Kotest framework on Js?

Any subclass of AbstractProjectConfig should be picked up by the JS compiler plugin and then activated before the tests begin.

I have this one in `commonTest`:

open class CommonTestConfiguration(
    private val loggingConfiguration: LoggingConfiguration = LoggingConfiguration(::emitViaPrintln)
) : AbstractProjectConfig() {

    override fun extensions() =
        listOf(
            LoggingTestProjectExtension(loggingConfiguration),
            DebugTraceTestProjectExtension
        )

    private class LoggingTestProjectExtension(val loggingConfiguration: LoggingConfiguration) : BeforeProjectListener {
        override suspend fun beforeProject() {
            loggingConfiguration.activate()
            <http://logger.info|logger.info> { "testVariant: $testVariant" }
        }
    }

    private object DebugTraceTestProjectExtension : ProjectExtension, SpecExtension, TestCaseExtension {
        override suspend fun interceptProject(context: ProjectContext, callback: suspend (ProjectContext) -> Unit) {
            DebugTrace.enabled = true // <- the effect of this one seems to be missed

            callback(context)
        }

        override suspend fun intercept(spec: Spec, execute: suspend (Spec) -> Unit) {
            execute(spec) // plus other stuff
        }

        override suspend fun intercept(testCase: TestCase, execute: suspend (TestCase) -> TestResult): TestResult =
            execute(testCase) // plus other stuff
    }
}

And this in a Js source set:

object TestConfiguration : CommonTestConfiguration(LoggingConfiguration(::emitViaPrintln))

interceptProject should work as it's just inside the shared engine code.

I'll try to find out more. Seems a bit hard to debug those pieces (but this may be due to my specific configuration), and console output seems to be unavailable either at this stage.

project config's have an after/before project method directly in them you can override too.

Could make the debugger work.

interceptProject

gets invoked. Actually, it seems to be invoked twice (but that's not an issue at this time). So the root cause of my issue (a global flag in a companion object having an unexpected value) might be unrelated to Kotest. Thanks so much for bearing with me!

Glad you were able to make progress.

Seems like the root cause was a lifecycle discrepancy between JVM and Js. My original code looked like this (yes, shortening it above to conserve reading bandwith was the wrong idea in this case):

override suspend fun interceptProject(context: ProjectContext, callback: suspend (ProjectContext) -> Unit) {
            val debugTraceEnabledBefore = DebugTrace.enabled
            DebugTrace.enabled = true

            callback(context)

            DebugTrace.enabled = debugTraceEnabledBefore
        }

On the JVM, the intercept's callback returns after all tests have completed. On Js, it returns before any test had a chance to run. The same applies to `AbstractProjectConfig`'s

afterProject

method. So on Js, the

enabled

setting got reset before a single test would run. Maybe it would be a good idea to harmonize lifecycle methods between different platforms, if feasible. Or at least document the exact order of invocations.

That sounds like a bug to me.

OK, in this case I'll prepare an issue along with a reproducer.

intercept project should have the same behavior across all platforms

Thanks for making the issue. Definitely a bug on JS that the spec/project exit occurs before any tests are executed.