#24 TS Compilation testing

buildSrc/build.gradle.kts

@@ -16,6 +16,7 @@ object Versions {
   const val kotlinxKover = "0.5.0"
   const val kotlinxSerialization = "1.3.2"
   const val ksp = "1.6.10-1.0.4"
+  const val gradleNodePlugin = "3.2.1"
 
   const val kotest = "5.2.3"
 }
@@ -36,9 +37,7 @@ dependencies {
   implementation("org.jetbrains.kotlinx:kotlinx-knit:${Versions.kotlinxKnit}")
   implementation("org.jetbrains.kotlinx:kover:${Versions.kotlinxKover}")
 
-//  implementation("org.jetbrains.reflekt:gradle-plugin:1.6.10-1-SNAPSHOT") {
-//    isChanging = true
-//  }
+  implementation("com.github.node-gradle:gradle-node-plugin:${Versions.gradleNodePlugin}")
 }
 
 

buildSrc/repositories.settings.gradle.kts

@@ -6,6 +6,20 @@ dependencyResolutionManagement {
     mavenCentral()
     jitpack()
     gradlePluginPortal()
+
+    // Declare the Node.js download repository
+    ivy("https://nodejs.org/dist/") {
+      name = "Node Distributions at $url"
+      patternLayout { artifact("v[revision]/[artifact](-v[revision]-[classifier]).[ext]") }
+      metadataSources { artifact() }
+      content { includeModule("org.nodejs", "node") }
+    }
+    ivy("https://github.com/yarnpkg/yarn/releases/download") {
+      name = "Yarn Distributions at $url"
+      patternLayout { artifact("v[revision]/[artifact](-v[revision]).[ext]") }
+      metadataSources { artifact() }
+      content { includeModule("com.yarnpkg", "yarn") }
+    }
   }
 
   pluginManagement {

buildSrc/src/main/kotlin/buildsrc/convention/kotlin-jvm.gradle.kts

@@ -13,7 +13,7 @@ plugins {
 }
 
 dependencies {
-  testImplementation(platform("io.kotest:kotest-bom:5.2.1"))
+  testImplementation(platform("io.kotest:kotest-bom:5.2.3"))
   testImplementation("io.kotest:kotest-runner-junit5")
   testImplementation("io.kotest:kotest-assertions-core")
   testImplementation("io.kotest:kotest-property")
@@ -49,6 +49,6 @@ tasks.compileTestKotlin {
   kotlinOptions.freeCompilerArgs += "-opt-in=io.kotest.common.ExperimentalKotest"
 }
 
-tasks.test {
+tasks.withType<Test>().configureEach {
   useJUnitPlatform()
 }

buildSrc/src/main/kotlin/buildsrc/convention/node.gradle.kts

@@ -0,0 +1,29 @@
+package buildsrc.convention
+
+plugins {
+  id("com.github.node-gradle.node")
+  id("buildsrc.convention.subproject")
+}
+
+val rootGradleDir: Directory by extra {
+  rootProject.layout.projectDirectory.dir(".gradle")
+}
+
+node {
+  download.set(true)
+
+  distBaseUrl.set(null as String?) // set in repositories.settings.gradle.kts
+
+  workDir.set(rootGradleDir.dir("nodejs"))
+  npmWorkDir.set(rootGradleDir.dir("npm"))
+  yarnWorkDir.set(rootGradleDir.dir("yarn"))
+}
+
+tasks.withType<Test> {
+  val npmInstallDir = tasks.npmSetup.map { it.npmDir.get().asFile.canonicalPath }
+  inputs.dir(npmInstallDir)
+
+  doFirst {
+    environment("NPM_INSTALL_DIR", npmInstallDir.get())
+  }
+}

docs/code/build.gradle.kts

@@ -1,10 +1,12 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
 plugins {
   buildsrc.convention.`kotlin-jvm`
+  buildsrc.convention.node
   kotlin("plugin.serialization")
   id("org.jetbrains.kotlinx.knit")
 }
 
-
 val kotlinxSerializationVersion = "1.3.2"
 
 dependencies {
@@ -14,17 +16,20 @@ dependencies {
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-core")
   implementation("org.jetbrains.kotlinx:kotlinx-serialization-json")
 
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1")
+
   implementation("org.jetbrains.kotlinx:kotlinx-knit:0.3.0")
 
   implementation(kotlin("reflect"))
 
-
   testImplementation(kotlin("test"))
 
   testImplementation("org.jetbrains.kotlinx:kotlinx-knit-test:0.3.0")
+  testImplementation("com.github.pgreze:kotlin-process:1.3.1")
 }
 
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+tasks.withType<KotlinCompile> {
+  mustRunAfter(tasks.knit)
   kotlinOptions.freeCompilerArgs += listOf(
     "-opt-in=kotlinx.serialization.ExperimentalSerializationApi",
   )
@@ -46,13 +51,9 @@ knit {
   }
 }
 
+tasks.withType<Test>().configureEach { dependsOn(tasks.knit) }
+
 tasks.test {
-  dependsOn(tasks.knit)
-//  finalizedBy(tasks.knitCheck)
+  // TSCompile tests are slow, they don't need to run every time
+  systemProperty("kotest.tags", "!TSCompile")
 }
-
-tasks.compileKotlin { mustRunAfter(tasks.knit) }
-
-//tasks.knitCheck {
-//  dependsOn(tasks.test)
-//}

docs/code/example/example-map-primitive-05.kt

@@ -7,7 +7,8 @@ import dev.adamko.kxstsgen.*
 
 @Serializable
 data class Config(
-  val properties: Map<String?, String?>
+  val nullableVals: Map<String, String?>,
+  val nullableKeys: Map<String?, String>,
 )
 
 fun main() {

docs/code/knit-test.ftl

@@ -4,32 +4,41 @@
 @file:Suppress("JSUnusedLocalSymbols")
 package ${test.package}
 
+import dev.adamko.kxstsgen.util.*
+<#--import io.kotest.assertions.*-->
+<#--import io.kotest.core.*-->
+import io.kotest.core.spec.style.*
 import io.kotest.matchers.*
+<#--import io.kotest.matchers.string.*-->
 import kotlinx.knit.test.*
-import org.junit.jupiter.api.Test
-import dev.adamko.kxstsgen.util.*
 
-class ${test.name} {
+class ${test.name} : FunSpec({
+
+  tags(Knit)
+
 <#list cases as case><#assign method = test["mode.${case.param}"]!"custom">
-  @Test
-  fun test${case.name}() {
-    captureOutput("${case.name}") {
+  context("${case.name}") {
+    val actual = captureOutput("${case.name}") {
       ${case.knit.package}.${case.knit.name}.main()
-    }<#if method != "custom">.${method}(
+    }.normalizeJoin()
+
+    test("expect actual matches TypeScript") {
+      actual.shouldBe(
         // language=TypeScript
         """
-<#list case.lines as line>
+          <#list case.lines as line>
           |${line}
-</#list>
+          </#list>
         """.trimMargin()
-          .normalize()
+        .normalize()
       )
-<#else>.also { lines ->
-      check(${case.param})
     }
-</#if>
+
+    test("expect actual compiles").config(tags = tsCompile) {
+      actual.shouldTypeScriptCompile()
+    }
   }
 <#sep>
 
 </#list>
-}
+})

docs/code/test/AbstractClassesTest.kt

@@ -2,35 +2,45 @@
 @file:Suppress("JSUnusedLocalSymbols")
 package dev.adamko.kxstsgen.example.test
 
+import dev.adamko.kxstsgen.util.*
+import io.kotest.core.spec.style.*
 import io.kotest.matchers.*
 import kotlinx.knit.test.*
-import org.junit.jupiter.api.Test
-import dev.adamko.kxstsgen.util.*
 
-class AbstractClassesTest {
-  @Test
-  fun testExampleAbstractClassSingleField01() {
-    captureOutput("ExampleAbstractClassSingleField01") {
+class AbstractClassesTest : FunSpec({
+
+  tags(Knit)
+
+  context("ExampleAbstractClassSingleField01") {
+    val actual = captureOutput("ExampleAbstractClassSingleField01") {
       dev.adamko.kxstsgen.example.exampleAbstractClassSingleField01.main()
     }.normalizeJoin()
-      .shouldBe(
+
+    test("expect actual matches TypeScript") {
+      actual.shouldBe(
         // language=TypeScript
         """
           |export type Color = any;
           |// interface Color {
           |//   rgb: number;
           |// }
         """.trimMargin()
-          .normalize()
+        .normalize()
       )
+    }
+
+    test("expect actual compiles").config(tags = tsCompile) {
+      actual.shouldTypeScriptCompile()
+    }
   }
 
-  @Test
-  fun testExampleAbstractClassPrimitiveFields01() {
-    captureOutput("ExampleAbstractClassPrimitiveFields01") {
+  context("ExampleAbstractClassPrimitiveFields01") {
+    val actual = captureOutput("ExampleAbstractClassPrimitiveFields01") {
       dev.adamko.kxstsgen.example.exampleAbstractClassPrimitiveFields01.main()
     }.normalizeJoin()
-      .shouldBe(
+
+    test("expect actual matches TypeScript") {
+      actual.shouldBe(
         // language=TypeScript
         """
           |export type SimpleTypes = any;
@@ -42,24 +52,35 @@ class AbstractClassesTest {
           |//   privateMember: string;
           |// }
         """.trimMargin()
-          .normalize()
+        .normalize()
       )
+    }
+
+    test("expect actual compiles").config(tags = tsCompile) {
+      actual.shouldTypeScriptCompile()
+    }
   }
 
-  @Test
-  fun testExampleAbstractClassAbstractField01() {
-    captureOutput("ExampleAbstractClassAbstractField01") {
+  context("ExampleAbstractClassAbstractField01") {
+    val actual = captureOutput("ExampleAbstractClassAbstractField01") {
       dev.adamko.kxstsgen.example.exampleAbstractClassAbstractField01.main()
     }.normalizeJoin()
-      .shouldBe(
+
+    test("expect actual matches TypeScript") {
+      actual.shouldBe(
         // language=TypeScript
         """
           |export type AbstractSimpleTypes = any;
           |// export interface AbstractSimpleTypes {
           |//   rgb: number;
           |// }
         """.trimMargin()
-          .normalize()
+        .normalize()
       )
+    }
+
+    test("expect actual compiles").config(tags = tsCompile) {
+      actual.shouldTypeScriptCompile()
+    }
   }
-}
+})