adds tests for multiple calls to symbol processors

Author: yigit

ksp/src/main/kotlin/com/tschuchort/compiletesting/Ksp.kt

@@ -6,43 +6,63 @@ package com.tschuchort.compiletesting
 import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingCommandLineProcessor
 import org.jetbrains.kotlin.ksp.KotlinSymbolProcessingComponentRegistrar
 import org.jetbrains.kotlin.ksp.processing.SymbolProcessor
+import java.io.File
 
 private const val KSP_PLUGIN_ID = "org.jetbrains.kotlin.ksp"
 
-fun KotlinCompilation.symbolProcessor(
+private fun KotlinCompilation.initAndGetKspConfig(): KspConfiguration {
+    val config = KspConfiguration(workingDir.resolve("ksp"))
+    if (config.workingDir.exists()) {
+        // already configured, just return
+        return config
+    }
+    config.classesOutDir.mkdirs()
+    config.sourcesOurDir.mkdirs()
+    config.syntheticSources.mkdirs()
+    val kspOptions = listOf(
+        PluginOption(KSP_PLUGIN_ID, "apclasspath", config.syntheticSources.path),
+        PluginOption(KSP_PLUGIN_ID, "classes", config.classesOutDir.path),
+        PluginOption(KSP_PLUGIN_ID, "sources", config.sourcesOurDir.path)
+    )
+    compilerPlugins = compilerPlugins + KotlinSymbolProcessingComponentRegistrar()
+    commandLineProcessors = commandLineProcessors + listOf(KotlinSymbolProcessingCommandLineProcessor())
+    pluginOptions = pluginOptions + kspOptions
+    return config
+}
+
+fun KotlinCompilation.symbolProcessors(
     vararg processors: Class<out SymbolProcessor>
 ) {
     check(processors.isNotEmpty()) {
         "Must provide at least 1 symbol processor"
     }
-    val kspWorkingDir = workingDir.resolve("ksp")
+    val config = initAndGetKspConfig()
 
     // create a fake classpath that references our symbol processor
-    val processorClasspath = kspWorkingDir.resolve("synthetic-ksp-service").apply {
+    config.syntheticSources.apply {
         resolve("META-INF/services/org.jetbrains.kotlin.ksp.processing.SymbolProcessor").apply {
             parentFile.mkdirs()
-            val processorNames = processors.joinToString(System.lineSeparator()) {
+            // keep existing ones in case this function is called multiple times
+            val existing = if (exists()) {
+                readLines(Charsets.UTF_8)
+            } else {
+                emptyList()
+            }
+            val processorNames = existing + processors.map {
                 it.typeName
             }
             writeText(
-                processorNames
+                processorNames.joinToString(System.lineSeparator())
             )
         }
     }
-
-    val classesFolder = kspWorkingDir.resolve("outClasses").also {
-        it.mkdirs()
-    }
-    val sourceFolder = kspWorkingDir.resolve("outSources").also {
-        it.mkdirs()
-    }
-    val kspOptions = listOf(
-        PluginOption(KSP_PLUGIN_ID, "apclasspath", processorClasspath.path),
-        PluginOption(KSP_PLUGIN_ID, "classes", classesFolder.path),
-        PluginOption(KSP_PLUGIN_ID, "sources", sourceFolder.path)
-    )
-    compilerPlugins = compilerPlugins + KotlinSymbolProcessingComponentRegistrar()
-    commandLineProcessors = commandLineProcessors + listOf(KotlinSymbolProcessingCommandLineProcessor())
-    pluginOptions = pluginOptions + kspOptions
     this.kaptSourceDir
 }
+
+private data class KspConfiguration(
+    val workingDir: File
+) {
+    val classesOutDir = workingDir.resolve("classesOutput")
+    val sourcesOurDir = workingDir.resolve("sourcesOutput")
+    val syntheticSources = workingDir.resolve("synthetic-ksp-service")
+}

ksp/src/test/kotlin/com/tschuchort/compiletesting/KspTest.kt

@@ -23,7 +23,7 @@ class KspTest {
     fun failedKspTest() {
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessor(processorRule.delegateTo(object : AbstractSymbolProcessor() {
+            symbolProcessors(processorRule.delegateTo(object : AbstractSymbolProcessor() {
                 override fun process(resolver: Resolver) {
                     throw RuntimeException("intentional fail")
                 }
@@ -38,7 +38,7 @@ class KspTest {
         val instance = mock<SymbolProcessor>()
         val result = KotlinCompilation().apply {
             sources = listOf(DUMMY_KOTLIN_SRC)
-            symbolProcessor(processorRule.delegateTo(instance))
+            symbolProcessors(processorRule.delegateTo(instance))
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
         instance.inOrder {
@@ -92,7 +92,7 @@ class KspTest {
         }
         val result = KotlinCompilation().apply {
             sources = listOf(annotation, targetClass)
-            symbolProcessor(processorRule.delegateTo(processor))
+            symbolProcessors(processorRule.delegateTo(processor))
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
@@ -105,12 +105,14 @@ class KspTest {
             package foo.bar
             import generated.A
             import generated.B
-            class Dummy(val a:A, val b:B)
+            import generated.C
+            class Dummy(val a:A, val b:B, val c:C)
         """.trimIndent()
         )
         val result = KotlinCompilation().apply {
             sources = listOf(source)
-            symbolProcessor(Write_foo_bar_A::class.java, Write_foo_bar_B::class.java)
+            symbolProcessors(Write_foo_bar_A::class.java, Write_foo_bar_B::class.java)
+            symbolProcessors(Write_foo_bar_C::class.java)
         }.compile()
         assertThat(result.exitCode).isEqualTo(ExitCode.OK)
     }
@@ -121,6 +123,9 @@ class KspTest {
     @Suppress("ClassName")
     internal class Write_foo_bar_B() : ClassGeneratingProcessor("generated", "B")
 
+    @Suppress("ClassName")
+    internal class Write_foo_bar_C() : ClassGeneratingProcessor("generated", "C")
+
     internal open class ClassGeneratingProcessor(
         private val packageName: String,
         private val className: String