fix(tests): add TestQueueFactory setup in beforeEach

Otherwise the rebuildContext was creating a new applicationContext that doesn't contain the testExecutions

Author: brian-mulier-p

core/src/test/java/io/kestra/core/runners/pebble/filters/DateFilterTest.java

@@ -14,13 +14,10 @@
 import java.util.Map;
 
 import jakarta.inject.Inject;
-import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.TestInstance.Lifecycle;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @KestraTest
-@TestInstance(Lifecycle.PER_CLASS)
 class DateFilterTest {
     public static final ZonedDateTime NOW = ZonedDateTime.parse("2013-09-08T16:19:12.123456+01");
 

jdbc-mysql/src/test/java/io/kestra/runner/mysql/MysqlRunnerRetryTest.java

@@ -1,10 +1,7 @@
 package io.kestra.runner.mysql;
 
 import io.kestra.jdbc.runner.JdbcRunnerRetryTest;
-import org.junit.jupiter.api.TestInstance;
-import org.junit.jupiter.api.TestInstance.Lifecycle;
 
-@TestInstance(Lifecycle.PER_CLASS)
 public class MysqlRunnerRetryTest extends JdbcRunnerRetryTest {
 
 }

scheduler/src/test/java/io/kestra/scheduler/AbstractSchedulerTest.java

@@ -34,7 +34,7 @@
 import java.util.Map;
 import java.util.Optional;
 
-@KestraTest(rebuildContext = true)
+@KestraTest
 abstract public class AbstractSchedulerTest {
     @Inject
     protected ApplicationContext applicationContext;

scheduler/src/test/java/io/kestra/scheduler/SchedulerScheduleTest.java

@@ -42,7 +42,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.*;
 
-@TestInstance(Lifecycle.PER_CLASS)
 public class SchedulerScheduleTest extends AbstractSchedulerTest {
     @Inject
     protected FlowListeners flowListenersService;
@@ -687,4 +686,4 @@ void recoverNONELongRunningExecution() throws Exception {
             Await.until(() -> this.triggerState.findLast(trigger).map(t -> t.getNextExecutionDate().isAfter(lastTrigger.getNextExecutionDate().plusSeconds(10))).orElse(false).booleanValue(), Duration.ofMillis(100), Duration.ofSeconds(20));
         }
     }
-}
+}

tests/src/main/java/io/kestra/core/junit/extensions/KestraTestExtension.java

@@ -1,25 +1,33 @@
 package io.kestra.core.junit.extensions;
 
 import io.kestra.core.junit.annotations.KestraTest;
+import io.kestra.core.models.executions.Execution;
 import io.kestra.core.models.executions.ExecutionKilled;
 import io.kestra.core.models.executions.ExecutionKilledExecution;
 import io.kestra.core.queues.QueueException;
 import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.queues.QueueInterface;
+import io.kestra.core.queues.TestQueueFactory;
 import io.kestra.core.repositories.ExecutionRepositoryInterface;
 import io.kestra.core.runners.TestRunner;
 import io.kestra.core.utils.TestsUtils;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.inject.BeanDefinition;
 import io.micronaut.inject.qualifiers.Qualifiers;
 import io.micronaut.test.annotation.MicronautTestValue;
 import io.micronaut.test.extensions.junit5.MicronautJunit5Extension;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.platform.commons.support.AnnotationSupport;
 
+import java.util.ArrayList;
 import java.util.ConcurrentModificationException;
+import java.util.List;
 
 @Slf4j
 public class KestraTestExtension extends MicronautJunit5Extension {
+    public static final ThreadLocal<List<Execution>> testExecutions = ThreadLocal.withInitial(ArrayList::new);
+
     private static final ExtensionContext.Namespace NAMESPACE = ExtensionContext.Namespace.create(KestraTestExtension.class);
 
     @Override
@@ -58,6 +66,7 @@ public void beforeAll(ExtensionContext extensionContext) throws Exception {
         KestraTest kestraTest = extensionContext.getTestClass()
             .orElseThrow()
             .getAnnotation(KestraTest.class);
+
         if (kestraTest.startRunner()) {
             TestRunner runner = applicationContext.getBean(TestRunner.class);
             if (!runner.isRunning()) {
@@ -68,6 +77,12 @@ public void beforeAll(ExtensionContext extensionContext) throws Exception {
         }
     }
 
+    @Override
+    public void beforeTestExecution(ExtensionContext context) {
+        TestQueueFactory testQueueFactory = applicationContext.getBean(TestQueueFactory.class);
+        testQueueFactory.setTestExecutionsList(testExecutions.get());
+    }
+
     @Override
     public void afterTestExecution(ExtensionContext context) throws Exception {
         super.afterTestExecution(context);
@@ -77,21 +92,22 @@ public void afterTestExecution(ExtensionContext context) throws Exception {
         KestraTest kestraTest = context.getTestClass()
             .orElseThrow()
             .getAnnotation(KestraTest.class);
-        if (kestraTest.startRunner()
+        if (!testExecutions.get().isEmpty() &&
+            kestraTest.startRunner()
             && applicationContext.containsBean(ExecutionRepositoryInterface.class)
             && applicationContext.containsBean(QueueInterface.class, Qualifiers.byName(QueueFactoryInterface.KILL_NAMED))) {
             ExecutionRepositoryInterface executionRepository = applicationContext.getBean(ExecutionRepositoryInterface.class);
             QueueInterface<ExecutionKilled> killQueue = applicationContext.getBean(QueueInterface.class, Qualifiers.byName(QueueFactoryInterface.KILL_NAMED));
 
             retryingExecutionKill(executionRepository, killQueue, 10);
 
-            TestRunner.testExecutions.get().clear();
+            testExecutions.get().clear();
         }
     }
 
     private void retryingExecutionKill(ExecutionRepositoryInterface executionRepository, QueueInterface<ExecutionKilled> killQueue, int retriesLeft) throws InterruptedException {
         try {
-            TestRunner.testExecutions.get().stream()
+            testExecutions.get().stream()
                 .flatMap(launchedExecution -> executionRepository.findById(launchedExecution.getTenantId(), launchedExecution.getId()).stream())
                 .filter(inRepository -> inRepository.getState().isRunning())
                 .forEach(inRepository -> {

tests/src/main/java/io/kestra/core/queues/TestQueueFactory.java

@@ -2,8 +2,10 @@
 
 import io.kestra.core.models.executions.Execution;
 import io.micronaut.context.annotation.Bean;
+import io.micronaut.context.annotation.Context;
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.context.annotation.Replaces;
+import io.micronaut.core.annotation.Introspected;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 
@@ -25,6 +27,7 @@ public void setTestExecutionsList(List<Execution> testExecutions) {
         this.testExecutions = testExecutions;
     }
 
+    @SuppressWarnings("unchecked")
     @Singleton
     @Replaces(named = QueueFactoryInterface.EXECUTION_NAMED)
     @Named(QueueFactoryInterface.EXECUTION_NAMED)

tests/src/main/java/io/kestra/core/runners/TestRunner.java

@@ -1,15 +1,11 @@
 package io.kestra.core.runners;
 
-import io.kestra.core.models.executions.Execution;
-import io.kestra.core.queues.TestQueueFactory;
-import io.kestra.core.queues.QueueFactoryInterface;
 import io.kestra.core.server.Service;
 import io.kestra.core.utils.Await;
 import io.kestra.core.utils.ExecutorsUtils;
 import io.kestra.worker.DefaultWorker;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.annotation.Value;
-import io.micronaut.inject.qualifiers.Qualifiers;
 import jakarta.annotation.PreDestroy;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
@@ -29,8 +25,6 @@
 @Slf4j
 @Singleton
 public class TestRunner implements Runnable, AutoCloseable {
-    public static final ThreadLocal<List<Execution>> testExecutions = ThreadLocal.withInitial(ArrayList::new);
-
     @Setter private int workerThread = Math.max(3, Runtime.getRuntime().availableProcessors()) * 16;
     @Setter private boolean schedulerEnabled = true;
     @Setter private boolean workerEnabled = true;
@@ -52,9 +46,6 @@ public class TestRunner implements Runnable, AutoCloseable {
 
     @Override
     public void run() {
-        TestQueueFactory executionQueue = applicationContext.getBean(TestQueueFactory.class);
-        executionQueue.setTestExecutionsList(testExecutions.get());
-
         running.set(true);
 
         poolExecutor = executorsUtils.cachedThreadPool("standalone-runner");