feat: Setup Kotest runner with output

.github/workflows/kotlin-test.yml

@@ -0,0 +1,29 @@
+name: Kotlin Tests
+
+on: [push, pull_request]
+
+jobs:
+  tests:
+    name: Kotlin Tests
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04]
+        rev: [nightly]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: "temurin"
+          java-version: 21
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Run tests
+        run: |
+          make kotlin-test

.github/workflows/test.yml → .github/workflows/lua-test.yml

@@ -1,10 +1,10 @@
-name: Tests
+name: Lua Tests
 
 on: [push, pull_request]
 
 jobs:
   tests:
-    name: tests
+    name: Lua Tests
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
@@ -32,4 +32,4 @@ jobs:
       - name: Run tests
         run: |
           nvim --version
-          make test
+          make lua-test

.gitignore

@@ -1,2 +1,4 @@
 .luarc.json
 .tests
+kotlin-test-launcher/maven-plugin/target/
+.idea

Makefile

@@ -1,11 +1,16 @@
-.PHONY: test clean format check
+.PHONY: lua-test kotlin-test test clean format check
 
 SOURCES := $(shell find lua tests -name *.lua)
 
 # timeout set to 3 mins (in milliseconds) to allow for gradle setup time
-test:
+lua-test:
 	nvim --headless --noplugin -u tests/bootstrap_init.lua -c "PlenaryBustedDirectory tests/ { minimal_init = './tests/minimal_init.lua', timeout = 180000 }"
 
+kotlin-test:
+	./kotlin-test-launcher/gradlew -p kotlin-test-launcher test
+
+test: lua-test kotlin-test
+
 clean:
 	rm -rf .tests
 

kotlin-test/.gitattributes

@@ -0,0 +1,12 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+
+# Binary files should be left untouched
+*.jar           binary
+

kotlin-test/.gitignore

@@ -0,0 +1,7 @@
+# Ignore Gradle project-specific cache directory
+.gradle
+
+# Ignore Gradle build output directory
+build
+
+.kotlin

kotlin-test/build.gradle.kts

@@ -0,0 +1,31 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+}
+
+allprojects {
+    group = "io.github.codymikol"
+
+    repositories {
+        mavenCentral()
+    }
+}
+
+subprojects {
+    apply(plugin = "org.jetbrains.kotlin.jvm")
+
+    tasks.withType<Test>().configureEach {
+        useJUnitPlatform()
+
+        // Only run tests that end with Spec
+        include("**/*Spec.class")
+
+        testLogging {
+            showStandardStreams = true
+            events(TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED)
+            exceptionFormat = TestExceptionFormat.FULL
+        }
+    }
+}

kotlin-test/core/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+    `java-library`
+    `maven-publish`
+}
+
+dependencies {
+    implementation(libs.kotest.framework.engine)
+    implementation(libs.coroutines)
+    implementation(libs.reflect)
+
+    testImplementation(libs.bundles.kotest)
+    testImplementation(libs.bundles.jackson)
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}
+
+kotlin {
+    explicitApi()
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("kotlin-test-core") {
+            groupId = project.group.toString()
+            artifactId = "kotlin-test-core"
+            version = "1.0.0"
+            from(components["java"])
+        }
+    }
+}

kotlin-test/core/src/main/kotlin/io/github/codymikol/kotlintestlauncher/TestFrameworkRunner.kt

@@ -0,0 +1,54 @@
+package io.github.codymikol.kotlintestlauncher
+
+import io.github.codymikol.kotlintestlauncher.kotest.KotestTestRunner
+import io.kotest.common.runBlocking
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.fold
+import kotlinx.coroutines.flow.map
+import kotlin.reflect.KClass
+
+/**
+ * Base interface for all test framework runners.
+ */
+public interface TestFrameworkRunner {
+    /**
+     * Runs the provided test [classes] using the [TestFrameworkRunner].
+     */
+    public suspend fun run(classes: Collection<KClass<*>>): TestRunResult
+
+    /**
+     * Whether this class is runnable by this [TestFrameworkRunner].
+     */
+    public fun isRunnable(kclass: KClass<*>): Boolean
+
+    public companion object {
+        /**
+         * Executes all tests using all supported [TestFrameworkRunner]s
+         * generating a [RunReport] that contains all classes and their corresponding test
+         * statuses.
+         */
+        public fun runAll(classes: Set<KClass<*>>): RunReport =
+            runBlocking {
+                flowOf<TestFrameworkRunner>(
+                    KotestTestRunner,
+                ).map { runner ->
+                    val runnableClasses = classes.filter { runner.isRunnable(it) }
+
+                    when (val result = runner.run(runnableClasses)) {
+                        is TestRunResult.Success -> result.report
+                        is TestRunResult.Failure -> TODO()
+                    }
+                }.fold(emptySet()) { acc, it -> acc + it }
+            }
+    }
+}
+
+public typealias RunReport = Set<TestNode.Container>
+
+public sealed interface TestRunResult {
+    public data class Success(
+        val report: RunReport,
+    ) : TestRunResult
+
+    public object Failure : TestRunResult
+}

kotlin-test/core/src/main/kotlin/io/github/codymikol/kotlintestlauncher/TestNode.kt

@@ -0,0 +1,180 @@
+package io.github.codymikol.kotlintestlauncher
+
+import io.kotest.core.test.TestResult
+import kotlin.time.Duration
+
+/**
+ * A test node, the parent union type of [TestNode.Test] and a [TestNode.Container]
+ * where a [TestNode.Test] is a terminal and a [TestNode.Container] can contain multiple
+ * other containers or tests.
+ */
+public sealed interface TestNode {
+    public val name: String
+
+    /**
+     * The total execution time of the [TestNode.Test] or all [TestNode.Container.nodes].
+     */
+    public val duration: Duration
+    public val type: TestNodeType
+
+    public enum class TestNodeType {
+        CONTAINER,
+        TEST,
+    }
+
+    /**
+     * Terminal node.
+     */
+    public data class Test(
+        override val name: String,
+        override val duration: Duration,
+        public val status: TestStatus,
+    ) : TestNode {
+        override val type: TestNodeType = TestNodeType.TEST
+    }
+
+    /**
+     * Can contain multiple other [Container]s or [Test]s inside of [nodes].
+     * This can be the root class node, top level namespace, or a nested namespace.
+     */
+    public data class Container(
+        override val name: String,
+    ) : TestNode {
+        private val nodes: MutableList<TestNode> = mutableListOf()
+        public val tests: List<TestNode>
+            get() = nodes.toList()
+
+        override val type: TestNodeType = TestNodeType.CONTAINER
+
+        override val duration: Duration
+            get() = this.nodes.fold(Duration.ZERO) { acc, it -> acc + it.duration }
+
+        public val status: Status
+            get() {
+                val tests: List<TestNode.Test> = this.visitAllNodes().filterIsInstance(TestNode.Test::class.java).toList()
+                return when {
+                    tests.all { it.status == TestStatus.Success } -> Status.SUCCESS
+                    tests.any { it.status is TestStatus.Failure } -> Status.FAILURE
+                    else -> Status.IGNORED
+                }
+            }
+
+        internal fun visitAllNodes(): Sequence<TestNode> {
+            val parent = this
+
+            return sequence {
+                val queue = mutableListOf<TestNode.Container>(parent)
+                while (queue.isNotEmpty()) {
+                    val container = queue.removeFirst()
+
+                    container.nodes.forEach { child ->
+                        yield(child)
+
+                        if (child is TestNode.Container) {
+                            queue.add(child)
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Adds the [node] to the [Container] appending onto potentially nested [TestNode.Container]s
+         * specified by [parentNames]. An empty list for [parentNames] means that it's top level.
+         *
+         * @throws IllegalArgumentException [parentNames] references a non-existent node or a node that
+         * isn't a [TestNode.Container].
+         */
+        @Throws(IllegalArgumentException::class)
+        internal fun add(
+            node: TestNode,
+            parentNames: List<String> = emptyList(),
+        ): Boolean {
+            val child =
+                parentNames.fold(this) { currentNode, parentName ->
+                    val child =
+                        requireNotNull(currentNode.nodes.find { it.name == parentName }) {
+                            "${this.name} > ${parentNames.joinToString(separator = " > ")} does not exist"
+                        }
+
+                    require(child is TestNode.Container) {
+                        "${this.name} > ${parentNames.joinToString(separator = " > ")} is not a TestNode.Container"
+                    }
+
+                    child
+                }
+
+            require(
+                !child.nodes.any { it.name == node.name },
+            ) { "${this.name} > ${parentNames.joinToString(separator = " > ")} > ${node.name} already exists" }
+
+            return child.nodes.add(node)
+        }
+    }
+}
+
+public enum class Status {
+    SUCCESS,
+    FAILURE,
+    IGNORED,
+}
+
+public sealed interface TestStatus {
+    public val type: Status
+
+    public object Success : TestStatus {
+        override val type: Status = Status.SUCCESS
+    }
+
+    public companion object {
+        internal fun from(kotestResult: TestResult): TestStatus =
+            when (kotestResult) {
+                is TestResult.Success -> Success
+                is TestResult.Failure -> {
+                    val error = kotestResult.errorOrNull
+
+                    Failure(
+                        stackTrace = error?.stackTraceToString(),
+                        error =
+                            error?.run {
+                                val traceOrigin = stackTrace?.firstOrNull()
+
+                                Failure.Error(
+                                    message = message,
+                                    lineNumber = traceOrigin?.lineNumber,
+                                    filename = traceOrigin?.fileName,
+                                )
+                            },
+                    )
+                }
+                is TestResult.Ignored -> Ignored(reason = kotestResult.reason)
+                is TestResult.Error -> TODO()
+            }
+    }
+
+    public data class Failure(
+        /**
+         * The entire stacktrace as a String, this is useful for displaying what
+         * a thrown exception would yield in the console.
+         */
+        public val stackTrace: String?,
+        /**
+         * Programmatic view of the original error.
+         */
+        public val error: Error?,
+    ) : TestStatus {
+        override val type: Status = Status.FAILURE
+
+        public data class Error(
+            public val message: String?,
+            public val lineNumber: Int?,
+            public val filename: String?,
+        )
+    }
+
+    public data class Ignored(
+        public val reason: String? = null,
+    ) : TestStatus {
+        override val type: Status = Status.IGNORED
+    }
+}