add a reproducer for #11758

Author: Jarvx

test-suite-kotlin-ksp/src/test/kotlin/io/micronaut/reproduce/ReplaceContextBeanSpec.kt

@@ -0,0 +1,141 @@
+package io.micronaut.reproduce
+
+import io.micronaut.context.ApplicationContext
+import io.micronaut.context.annotation.Context
+import io.micronaut.context.annotation.Replaces
+import io.micronaut.context.annotation.Requires
+import io.micronaut.core.annotation.Order
+import jakarta.inject.Singleton
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Test
+import kotlin.test.assertTrue
+
+// Minimal, self-contained reproduction of the @Context / @Replaces nondeterministic behavior.
+// All beans are guarded by a test property so they do not affect other tests.
+
+interface DemoService
+
+@Context
+@Requires(property = "spec.name", value = "replace-context")
+open class OriginalDemoService : DemoService {
+    companion object {
+        @Volatile
+        var created = 0
+    }
+
+    init {
+        created++
+        // make sure construction side-effects are visible in logs
+        System.err.println("[OriginalDemoService] created (count=$created)")
+    }
+}
+
+// Replacement intentionally does NOT use @Context. It should replace the OriginalDemoService
+// definition. If replacement does not replace the @Context scoped bean definition properly,
+// the OriginalDemoService may still be instantiated at startup (the bug under investigation).
+@Replaces(OriginalDemoService::class)
+@Singleton
+@Requires(property = "spec.name", value = "replace-context")
+open class ReplacementDemoService : DemoService {
+    companion object {
+        @Volatile
+        var created = 0
+    }
+
+    init {
+        created++
+        System.err.println("[ReplacementDemoService] created (count=$created)")
+    }
+}
+
+// Two eager consumers with explicit order to force different initialization sequences.
+// They are @Context so they initialize during context start.
+@Context
+@Order(-1000)
+@Requires(property = "spec.name", value = "replace-context")
+@Requires(property = "scenario", value = "early")
+class EarlyConsumer(bean: DemoService) {
+    companion object {
+        @Volatile
+        var injected: DemoService? = null
+    }
+
+    init {
+        injected = bean
+        System.err.println("[EarlyConsumer] injected -> ${'$'}{bean::class.qualifiedName}")
+    }
+}
+
+@Context
+@Order(100)
+@Requires(property = "spec.name", value = "replace-context")
+@Requires(property = "scenario", value = "late")
+class LateConsumer(bean: DemoService) {
+    companion object {
+        @Volatile
+        var injected: DemoService? = null
+    }
+
+    init {
+        injected = bean
+        System.err.println("[LateConsumer] injected -> ${'$'}{bean::class.qualifiedName}")
+    }
+}
+
+class ReplaceContextBeanSpec {
+
+    @AfterEach
+    fun cleanup() {
+        OriginalDemoService.created = 0
+        ReplacementDemoService.created = 0
+        EarlyConsumer.injected = null
+        LateConsumer.injected = null
+    }
+
+    @Test
+    fun `replacement should prevent original @Context instantiation when consumer is early`() {
+        val ctx = ApplicationContext.run(mapOf("spec.name" to "replace-context", "scenario" to "early"))
+        try {
+            // Collect diagnostics
+            val originalCount = OriginalDemoService.created
+            val replacementCount = ReplacementDemoService.created
+            val injected = EarlyConsumer.injected
+
+            // If the replacement worked properly, the original @Context must not be instantiated at all
+            // and the injected instance must be the ReplacementDemoService.
+            if (originalCount != 0 || replacementCount != 1 || injected !is ReplacementDemoService) {
+                throw AssertionError(
+                    "Early scenario: unexpected outcome:\n" +
+                        "  OriginalDemoService.created=$originalCount\n" +
+                        "  ReplacementDemoService.created=$replacementCount\n" +
+                        "  EarlyConsumer.injected=${injected?.let { it::class.qualifiedName } ?: "<null>"}\n" +
+                        "  (Expected: original.created=0, replacement.created=1, injected -> ReplacementDemoService)"
+                )
+            }
+        } finally {
+            ctx.close()
+        }
+    }
+
+    @Test
+    fun `replacement should prevent original @Context instantiation when consumer is late`() {
+        val ctx = ApplicationContext.run(mapOf("spec.name" to "replace-context", "scenario" to "late"))
+        try {
+            val originalCount = OriginalDemoService.created
+            val replacementCount = ReplacementDemoService.created
+            val injected = LateConsumer.injected
+
+            if (originalCount != 0 || replacementCount != 1 || injected !is ReplacementDemoService) {
+                throw AssertionError(
+                    "Late scenario: unexpected outcome:\n" +
+                        "  OriginalDemoService.created=$originalCount\n" +
+                        "  ReplacementDemoService.created=$replacementCount\n" +
+                        "  LateConsumer.injected=${injected?.let { it::class.qualifiedName } ?: "<null>"}\n" +
+                        "  (Expected: original.created=0, replacement.created=1, injected -> ReplacementDemoService)"
+                )
+            }
+        } finally {
+            ctx.close()
+        }
+    }
+}