Exclude opt-in test tags by default

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: amichne

build-logic/AGENTS.md

@@ -28,6 +28,11 @@ Assume every edit in this unit can affect the whole repo.
 
 Validate both the immediate target and the wider build impact.
 
+- For test-tag selection behavior, run
+  `./gradlew -p build-logic test --tests DefaultTestTagSelectionTest`.
+- Convention plugin test filtering supports `-PincludeTags=<tag1,tag2>` and
+  `-PexcludeTags=<tag1,tag2>`. Default runs exclude `concurrency`,
+  `performance`, and `parity` unless include tags are set.
 - Run the affected module tasks that consume the changed convention, starting
   with `./gradlew :kast:syncRuntimeLibs :kast:writeWrapperScript` for wrapper
   or runtime-lib changes.

build-logic/build.gradle.kts

@@ -19,4 +19,10 @@ dependencies {
     implementation(catalog.findLibrary("kotlin-gradle-plugin").get())
     implementation(catalog.findLibrary("kotlin-serialization-plugin").get())
     implementation("com.gradleup.shadow:com.gradleup.shadow.gradle.plugin:${catalog.findVersion("shadow").get().requiredVersion}")
+    testImplementation(catalog.findLibrary("junit-jupiter").get())
+    testRuntimeOnly(catalog.findLibrary("junit-platform-launcher").get())
+}
+
+tasks.test {
+    useJUnitPlatform()
 }

build-logic/src/main/kotlin/DefaultTestTagSelection.kt

@@ -0,0 +1,31 @@
+internal data class TestTagSelection(
+    val included: Set<String>,
+    val excluded: Set<String>,
+)
+
+internal object DefaultTestTagSelection {
+    private val defaultExcludedTags = linkedSetOf("concurrency", "performance", "parity")
+
+    fun from(includeTags: String?, excludeTags: String?): TestTagSelection {
+        val included = parseTags(includeTags)
+        val excluded = linkedSetOf<String>().apply {
+            if (included.isEmpty()) {
+                addAll(defaultExcludedTags)
+            }
+            addAll(parseTags(excludeTags))
+        }
+        return TestTagSelection(
+            included = included,
+            excluded = excluded,
+        )
+    }
+
+    private fun parseTags(rawTags: String?): LinkedHashSet<String> =
+        rawTags
+            ?.split(",")
+            ?.asSequence()
+            ?.map(String::trim)
+            ?.filter(String::isNotEmpty)
+            ?.toCollection(linkedSetOf())
+            ?: linkedSetOf()
+}

build-logic/src/main/kotlin/kast.kotlin-library.gradle.kts

@@ -19,13 +19,15 @@ kotlin {
 
 tasks.withType<Test>().configureEach {
     useJUnitPlatform {
-        val exclude = providers.gradleProperty("excludeTags").orNull
-        val include = providers.gradleProperty("includeTags").orNull
-        if (!exclude.isNullOrBlank()) {
-            excludeTags(*exclude.split(",").map(String::trim).toTypedArray())
+        val tagSelection = DefaultTestTagSelection.from(
+            includeTags = providers.gradleProperty("includeTags").orNull,
+            excludeTags = providers.gradleProperty("excludeTags").orNull,
+        )
+        if (tagSelection.excluded.isNotEmpty()) {
+            excludeTags(*tagSelection.excluded.toTypedArray())
         }
-        if (!include.isNullOrBlank()) {
-            includeTags(*include.split(",").map(String::trim).toTypedArray())
+        if (tagSelection.included.isNotEmpty()) {
+            includeTags(*tagSelection.included.toTypedArray())
         }
     }
 }

build-logic/src/test/kotlin/DefaultTestTagSelectionTest.kt

@@ -0,0 +1,43 @@
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class DefaultTestTagSelectionTest {
+    @Test
+    fun `default test runs exclude opt-in suites`() {
+        val selection = DefaultTestTagSelection.from(
+            includeTags = null,
+            excludeTags = null,
+        )
+
+        assertEquals(emptySet<String>(), selection.included)
+        assertEquals(
+            linkedSetOf("concurrency", "performance", "parity"),
+            selection.excluded,
+        )
+    }
+
+    @Test
+    fun `explicit include tags suppress default exclusions`() {
+        val selection = DefaultTestTagSelection.from(
+            includeTags = "concurrency",
+            excludeTags = null,
+        )
+
+        assertEquals(linkedSetOf("concurrency"), selection.included)
+        assertEquals(emptySet<String>(), selection.excluded)
+    }
+
+    @Test
+    fun `explicit excludes merge with default opt-in exclusions`() {
+        val selection = DefaultTestTagSelection.from(
+            includeTags = null,
+            excludeTags = "slow",
+        )
+
+        assertEquals(emptySet<String>(), selection.included)
+        assertEquals(
+            linkedSetOf("concurrency", "performance", "parity", "slow"),
+            selection.excluded,
+        )
+    }
+}