feat: TargetSystemManager available as dependency (#734)

Author: dieppa

core/flamingock-core/src/main/java/io/flamingock/internal/core/builder/change/AbstractChangeRunnerBuilder.java

@@ -231,6 +231,7 @@ private LoadedPipeline loadPipeline() {
     private PriorityContext buildContext() {
         logger.trace("injecting internal configuration");
         addDependency(coreConfiguration);
+        addDependency(targetSystemManager);
         updateContextSpecific();
         List<ContextResolver> dependencyContextsFromPlugins = pluginManager.getPlugins()
                 .stream()

core/flamingock-core/src/main/java/io/flamingock/internal/core/targets/TargetSystemManager.java

@@ -71,19 +71,6 @@ public void add(TargetSystem targetSystem) {
     }
 
 
-    /**
-     * Registers the default {@link TargetSystem} to be returned when a specific ID is not found.
-     * <p>
-     * Also adds it to the general registry.
-     *
-     * @param defaultTargetSystem the default target system
-     * @throws IllegalArgumentException if the target system or its ID is null/blank
-     */
-    public void setAuditStoreTargetSystem(TargetSystem defaultTargetSystem) {
-        add(defaultTargetSystem);
-        this.auditStoreTargetSystem = (AbstractTargetSystem<?>) defaultTargetSystem;
-    }
-
     /**
      * Returns the {@link TargetSystem} associated with the given descriptor.
      * 

e2e/core-e2e/src/test/java/io/flamingock/core/e2e/BuilderE2ETest.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 Flamingock (https://www.flamingock.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.flamingock.core.e2e;
+
+import io.flamingock.common.test.pipeline.CodeChangeTestDefinition;
+import io.flamingock.common.test.pipeline.PipelineTestHelper;
+import io.flamingock.core.e2e.changes._008__TargetSystemManagerInjectionChange;
+import io.flamingock.core.e2e.helpers.Counter;
+import io.flamingock.core.kit.audit.AuditTestHelper;
+import io.flamingock.core.kit.inmemory.InMemoryTestKit;
+import io.flamingock.internal.common.core.util.Deserializer;
+import io.flamingock.internal.core.targets.TargetSystemManager;
+import io.flamingock.targetsystem.nontransactional.NonTransactionalTargetSystem;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.util.Arrays;
+
+import static io.flamingock.core.kit.audit.AuditEntryExpectation.APPLIED;
+import static io.flamingock.core.kit.audit.AuditEntryExpectation.STARTED;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+class BuilderE2ETest {
+
+    @Test
+    @DisplayName("Should inject TargetSystemManager as dependency in change")
+    void shouldInjectTargetSystemManagerInChange() {
+        // Given - Create isolated test kit with domain-separated helpers
+        InMemoryTestKit testKit = InMemoryTestKit.create();
+        AuditTestHelper auditHelper = testKit.getAuditHelper();
+
+        Counter counter = new Counter();
+
+        NonTransactionalTargetSystem targetSystem = new NonTransactionalTargetSystem("kafka")
+                .addDependency(counter);
+
+        try (MockedStatic<Deserializer> mocked = Mockito.mockStatic(Deserializer.class)) {
+            mocked.when(Deserializer::readPreviewPipelineFromFile).thenReturn(
+                    PipelineTestHelper.getPreviewPipeline(
+                            new CodeChangeTestDefinition(
+                                    _008__TargetSystemManagerInjectionChange.class,
+                                    Arrays.asList(TargetSystemManager.class, Counter.class)
+                            )
+                    )
+            );
+
+            // When - Execute using test builder
+            testKit.createBuilder()
+                    .addTargetSystem(targetSystem)
+                    .build()
+                    .run();
+        }
+
+        // Then - Verify that TargetSystemManager was successfully injected
+        assertTrue(counter.isExecuted(), "Counter.executed should be true, indicating TargetSystemManager was injected");
+
+        // Verify complete audit flow
+        auditHelper.verifyAuditSequenceStrict(
+                STARTED("test8-target-system-manager-injection"),
+                APPLIED("test8-target-system-manager-injection")
+        );
+    }
+}

e2e/core-e2e/src/test/java/io/flamingock/core/e2e/changes/_008__TargetSystemManagerInjectionChange.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2025 Flamingock (https://www.flamingock.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.flamingock.core.e2e.changes;
+
+import io.flamingock.api.annotations.Change;
+import io.flamingock.api.annotations.Apply;
+import io.flamingock.api.annotations.NonLockGuarded;
+import io.flamingock.api.annotations.TargetSystem;
+import io.flamingock.core.e2e.helpers.Counter;
+import io.flamingock.internal.core.targets.TargetSystemManager;
+
+/**
+ * Change that receives TargetSystemManager as a dependency to verify
+ * that it can be injected into changes.
+ */
+@Change(id = "test8-target-system-manager-injection", transactional = false, author = "aperezdieppa")
+@TargetSystem(id = "kafka")
+public class _008__TargetSystemManagerInjectionChange {
+
+    @Apply
+    public void apply(TargetSystemManager targetSystemManager, @NonLockGuarded Counter counter) {
+        if (targetSystemManager != null) {
+            counter.setExecuted(true);
+            System.out.println("TargetSystemManager successfully injected");
+        } else {
+            throw new RuntimeException("TargetSystemManager was not injected");
+        }
+    }
+}