jprdonnelly/kestra
1
0
Fork 0
mirror of https://github.com/kestra-io/kestra.git synced 2025-12-19 18:05:41 -05:00
Code Issues Packages Projects Releases Wiki Activity

feat(memory): remove memory runner and introduce @KestraTest (#3948)

Browse Source
This commit is contained in:
brian-mulier-p
2024-06-12 19:17:57 +02:00
committed by GitHub
parent a0da24dfa1
commit b15d2cf409
214 changed files with 1058 additions and 3383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cli/src/main/java/io/kestra/cli/commands/flows/FlowTestCommand.java
View File

@@ -7,7 +7,7 @@ import io.kestra.core.repositories.FlowRepositoryInterface;
import io.kestra.core.repositories.LocalFlowRepositoryLoader;
import io.kestra.core.runners.FlowInputOutput;
import io.kestra.core.runners.RunnerUtils;
import io.kestra.runner.memory.MemoryRunner;
import io.kestra.core.runners.StandAloneRunner;
import io.micronaut.context.ApplicationContext;
import jakarta.inject.Inject;
import jakarta.validation.ConstraintViolationException;
@@ -71,7 +71,7 @@ public class FlowTestCommand extends AbstractCommand {
public Integer call() throws Exception {
super.call();
MemoryRunner runner = applicationContext.getBean(MemoryRunner.class);
StandAloneRunner runner = applicationContext.getBean(StandAloneRunner.class);
LocalFlowRepositoryLoader repositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
FlowRepositoryInterface flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
FlowInputOutput flowInputOutput = applicationContext.getBean(FlowInputOutput.class);

2
cli/src/main/java/io/kestra/cli/commands/servers/StandAloneCommand.java
View File

@@ -83,7 +83,7 @@ public class StandAloneCommand extends AbstractServerCommand {
if (flowPath != null) {
try {
LocalFlowRepositoryLoader localFlowRepositoryLoader = applicationContext.getBean(LocalFlowRepositoryLoader.class);
localFlowRepositoryLoader.load(this.flowPath, true);
localFlowRepositoryLoader.load(this.flowPath);
} catch (IOException e) {
throw new CommandLine.ParameterException(this.spec.commandLine(), "Invalid flow path", e);
}

50
cli/src/main/resources/application.yml
View File

@@ -123,56 +123,6 @@ kestra:
delay: 1s
maxDelay: ""
jdbc:
tables:
queues:
table: "queues"
flows:
table: "flows"
cls: io.kestra.core.models.flows.Flow
executions:
table: "executions"
cls: io.kestra.core.models.executions.Execution
templates:
table: "templates"
cls: io.kestra.core.models.templates.Template
triggers:
table: "triggers"
cls: io.kestra.core.models.triggers.Trigger
logs:
table: "logs"
cls: io.kestra.core.models.executions.LogEntry
metrics:
table: "metrics"
cls: io.kestra.core.models.executions.MetricEntry
multipleconditions:
table: "multipleconditions"
cls: io.kestra.core.models.triggers.multipleflows.MultipleConditionWindow
subflow_executions:
table: "subflow_executions"
cls: io.kestra.core.runners.SubflowExecution
executorstate:
table: "executorstate"
cls: io.kestra.core.runners.ExecutorState
executordelayed:
table: "executordelayed"
cls: io.kestra.core.runners.ExecutionDelay
settings:
table: "settings"
cls: io.kestra.core.models.Setting
flowtopologies:
table: "flow_topologies"
cls: io.kestra.core.models.topologies.FlowTopology
serviceinstance:
cls: io.kestra.core.server.ServiceInstance
table: "service_instance"
workerjobrunning:
cls: io.kestra.core.runners.WorkerJobRunning
table: "worker_job_running"
executionqueued:
table: "execution_queued"
cls: io.kestra.core.runners.ExecutionQueued
queues:
min-poll-interval: 25ms
max-poll-interval: 1000ms

5
cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceCommandTest.java
View File

@@ -2,15 +2,14 @@ package io.kestra.cli.commands.flows.namespaces;
import io.micronaut.configuration.picocli.PicocliRunner;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringStartsWith.startsWith;
class FlowNamespaceCommandTest {
@Test
@@ -23,7 +22,7 @@ class FlowNamespaceCommandTest {
Integer call = PicocliRunner.call(FlowNamespaceCommand.class, ctx, args);
assertThat(call, is(0));
assertThat(out.toString(), startsWith("Usage: kestra flow namespace"));
assertThat(out.toString(), containsString("Usage: kestra flow namespace"));
}
}
}

4
cli/src/test/java/io/kestra/cli/commands/namespaces/NamespaceCommandTest.java
View File

@@ -8,8 +8,8 @@ import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringStartsWith.startsWith;
class NamespaceCommandTest {
@Test
@@ -22,7 +22,7 @@ class NamespaceCommandTest {
Integer call = PicocliRunner.call(NamespaceCommand.class, ctx, args);
assertThat(call, is(0));
assertThat(out.toString(), startsWith("Usage: kestra namespace"));
assertThat(out.toString(), containsString("Usage: kestra namespace"));
}
}
}

5
cli/src/test/java/io/kestra/cli/commands/namespaces/files/NamespaceFilesCommandTest.java
View File

@@ -2,15 +2,14 @@ package io.kestra.cli.commands.namespaces.files;
import io.micronaut.configuration.picocli.PicocliRunner;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringStartsWith.startsWith;
class NamespaceFilesCommandTest {
@Test
@@ -23,7 +22,7 @@ class NamespaceFilesCommandTest {
Integer call = PicocliRunner.call(NamespaceFilesCommand.class, ctx, args);
assertThat(call, is(0));
assertThat(out.toString(), startsWith("Usage: kestra namespace files"));
assertThat(out.toString(), containsString("Usage: kestra namespace files"));
}
}
}

4
cli/src/test/java/io/kestra/cli/commands/sys/database/DatabaseCommandTest.java
View File

@@ -8,8 +8,8 @@ import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringStartsWith.startsWith;
class DatabaseCommandTest {
@Test
@@ -22,7 +22,7 @@ class DatabaseCommandTest {
Integer call = PicocliRunner.call(DatabaseCommand.class, ctx, args);
assertThat(call, is(0));
assertThat(out.toString(), startsWith("Usage: kestra sys database"));
assertThat(out.toString(), containsString("Usage: kestra sys database"));
}
}
}

4
cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceCommandTest.java
View File

@@ -8,8 +8,8 @@ import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.core.Is.is;
import static org.hamcrest.core.StringStartsWith.startsWith;
class TemplateNamespaceCommandTest {
@Test
@@ -22,7 +22,7 @@ class TemplateNamespaceCommandTest {
Integer call = PicocliRunner.call(TemplateNamespaceCommand.class, ctx, args);
assertThat(call, is(0));
assertThat(out.toString(), startsWith("Usage: kestra template namespace"));
assertThat(out.toString(), containsString("Usage: kestra template namespace"));
}
}
}

8
core/src/main/java/io/kestra/core/contexts/KestraContext.java
View File

@@ -59,14 +59,14 @@ public abstract class KestraContext {
* @return the string version.
*/
public abstract String getVersion();
/**
* Returns the Kestra Plugin Registry.
*
* @return the {@link PluginRegistry}.
*/
public abstract PluginRegistry getPluginRegistry();
/**
* Shutdowns the Kestra application.
*/
@@ -106,7 +106,7 @@ public abstract class KestraContext {
public ServerType getServerType() {
return Optional.ofNullable(environment)
.flatMap(env -> env.getProperty(KESTRA_SERVER_TYPE, ServerType.class))
.orElseThrow(() -> new IllegalStateException("Cannot found required environment property '" + KESTRA_SERVER_TYPE + "'."));
.orElse(ServerType.STANDALONE);
}
/** {@inheritDoc} **/
@@ -124,7 +124,7 @@ public abstract class KestraContext {
public String getVersion() {
return version;
}
/** {@inheritDoc} **/
@Override
public PluginRegistry getPluginRegistry() {

22
core/src/main/java/io/kestra/core/repositories/LocalFlowRepositoryLoader.java
View File

@@ -18,7 +18,10 @@ import java.nio.charset.Charset;
import java.nio.file.*;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import jakarta.validation.ConstraintViolationException;
@@ -65,12 +68,9 @@ public class LocalFlowRepositoryLoader {
}
}
public void load(File basePath) throws IOException {
this.load(basePath, false);
}
public void load(File basePath, Boolean update) throws IOException {
Map<String, Flow> flowByUidInRepository = flowRepository.findAllForAllTenants().stream()
.collect(Collectors.toMap(Flow::uidWithoutRevision, Function.identity()));
List<Path> list = Files.walk(basePath.toPath())
.filter(YamlFlowParser::isValidExtension)
.toList();
@@ -81,16 +81,12 @@ public class LocalFlowRepositoryLoader {
Flow parse = yamlFlowParser.parse(file.toFile(), Flow.class);
modelValidator.validate(parse);
if (!update) {
Flow inRepository = flowByUidInRepository.get(parse.uidWithoutRevision());
if (inRepository == null) {
this.createFlow(flowSource, parse);
} else {
Optional<Flow> find = flowRepository.findById(parse.getTenantId(), parse.getNamespace(), parse.getId());
if (find.isEmpty()) {
this.createFlow(flowSource, parse);
} else {
this.udpateFlow(flowSource, parse, find.get());
}
this.udpateFlow(flowSource, parse, inRepository);
}
} catch (ConstraintViolationException e) {
log.warn("Unable to create flow {}", file, e);

52
core/src/main/java/io/kestra/core/runners/Indexer.java
View File

@@ -11,12 +11,17 @@ import io.kestra.core.repositories.LogRepositoryInterface;
import io.kestra.core.repositories.MetricRepositoryInterface;
import io.kestra.core.repositories.SaveRepositoryInterface;
import io.kestra.core.repositories.TriggerRepositoryInterface;
import io.kestra.core.server.ServiceStateChangeEvent;
import io.kestra.core.utils.IdUtils;
import io.micronaut.context.annotation.Requires;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import io.micronaut.context.event.ApplicationEventPublisher;
import jakarta.annotation.PreDestroy;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import jakarta.inject.Singleton;
@@ -36,6 +41,10 @@ public class Indexer implements IndexerInterface {
private final MetricRegistry metricRegistry;
private final List<Runnable> receiveCancellations = new ArrayList<>();
private final String id = IdUtils.create();
private final AtomicReference<ServiceState> state = new AtomicReference<>();
private final ApplicationEventPublisher<ServiceStateChangeEvent> eventPublisher;
@Inject
public Indexer(
ExecutionRepositoryInterface executionRepository,
@@ -44,7 +53,8 @@ public class Indexer implements IndexerInterface {
@Named(QueueFactoryInterface.WORKERTASKLOG_NAMED) QueueInterface<LogEntry> logQueue,
MetricRepositoryInterface metricRepositor,
@Named(QueueFactoryInterface.METRIC_QUEUE) QueueInterface<MetricEntry> metricQueue,
MetricRegistry metricRegistry
MetricRegistry metricRegistry,
ApplicationEventPublisher<ServiceStateChangeEvent> eventPublisher
) {
this.executionRepository = executionRepository;
this.executionQueue = executionQueue;
@@ -53,6 +63,8 @@ public class Indexer implements IndexerInterface {
this.metricRepository = metricRepositor;
this.metricQueue = metricQueue;
this.metricRegistry = metricRegistry;
this.eventPublisher = eventPublisher;
setState(ServiceState.CREATED);
}
@Override
@@ -60,6 +72,7 @@ public class Indexer implements IndexerInterface {
this.send(executionQueue, executionRepository);
this.send(logQueue, logRepository);
this.send(metricQueue, metricRepository);
setState(ServiceState.RUNNING);
}
protected <T> void send(QueueInterface<T> queueInterface, SaveRepositoryInterface<T> saveRepositoryInterface) {
@@ -80,11 +93,40 @@ public class Indexer implements IndexerInterface {
}));
}
protected void setState(final ServiceState state) {
this.state.set(state);
this.eventPublisher.publishEvent(new ServiceStateChangeEvent(this));
}
/** {@inheritDoc} **/
@Override
public void close() throws IOException {
public String getId() {
return id;
}
/** {@inheritDoc} **/
@Override
public ServiceType getType() {
return ServiceType.INDEXER;
}
/** {@inheritDoc} **/
@Override
public ServiceState getState() {
return state.get();
}
@PreDestroy
@Override
public void close() {
setState(ServiceState.TERMINATING);
this.receiveCancellations.forEach(Runnable::run);
this.executionQueue.close();
this.logQueue.close();
this.metricQueue.close();
try {
this.executionQueue.close();
this.logQueue.close();
this.metricQueue.close();
setState(ServiceState.TERMINATED_GRACEFULLY);
} catch (IOException e) {
log.error("Failed to close the queue", e);
setState(ServiceState.TERMINATED_FORCED);
}
}
}

4
core/src/main/java/io/kestra/core/runners/IndexerInterface.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.runners;
import java.io.Closeable;
import io.kestra.core.server.Service;
public interface IndexerInterface extends Runnable, Closeable {
public interface IndexerInterface extends Service, Runnable {
}

4
core/src/main/java/io/kestra/core/runners/RunnerUtils.java
View File

@@ -167,11 +167,11 @@ public class RunnerUtils {
public Execution awaitExecution(Predicate<Execution> predicate, Runnable executionEmitter, Duration duration) throws TimeoutException {
AtomicReference<Execution> receive = new AtomicReference<>();
Runnable cancel = this.executionQueue.receive(current -> {
Runnable cancel = this.executionQueue.receive(null, current -> {
if (predicate.test(current.getLeft())) {
receive.set(current.getLeft());
}
});
}, false);
executionEmitter.run();

29
core/src/main/java/io/kestra/core/runners/StandAloneRunner.java
View File

@@ -1,21 +1,30 @@
package io.kestra.core.runners;
import io.kestra.core.schedulers.AbstractScheduler;
import io.kestra.core.server.Service;
import io.kestra.core.utils.Await;
import io.kestra.core.utils.ExecutorsUtils;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.annotation.Requires;
import io.micronaut.context.annotation.Value;
import jakarta.inject.Inject;
import jakarta.inject.Singleton;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import static io.kestra.core.utils.Rethrow.throwConsumer;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeoutException;
@Slf4j
@Singleton
@Requires(missingBeans = RunnerInterface.class)
public class StandAloneRunner implements RunnerInterface, AutoCloseable {
private java.util.concurrent.ExecutorService poolExecutor;
private ExecutorService poolExecutor;
@Setter protected int workerThread = Math.max(3, Runtime.getRuntime().availableProcessors());
@Setter protected boolean schedulerEnabled = true;
@Setter protected boolean workerEnabled = true;
@@ -26,7 +35,10 @@ public class StandAloneRunner implements RunnerInterface, AutoCloseable {
@Inject
private ApplicationContext applicationContext;
private final List<AutoCloseable> servers = new ArrayList<>();
@Value("${kestra.server.standalone.running.timeout:PT1M}")
private Duration runningTimeout;
private final List<Service> servers = new ArrayList<>();
private boolean running = false;
@@ -57,6 +69,15 @@ public class StandAloneRunner implements RunnerInterface, AutoCloseable {
poolExecutor.execute(indexer);
servers.add(indexer);
}
try {
Await.until(() -> servers.stream().allMatch(s -> Optional.ofNullable(s.getState()).orElse(Service.ServiceState.RUNNING).isRunning()), null, runningTimeout);
} catch (TimeoutException e) {
throw new RuntimeException(
servers.stream().filter(s -> !Optional.ofNullable(s.getState()).orElse(Service.ServiceState.RUNNING).isRunning())
.map(Service::getClass)
.toList() + " not started in time");
}
}
public boolean isRunning() {

2
core/src/main/java/io/kestra/core/runners/Worker.java
View File

@@ -178,7 +178,6 @@ public class Worker implements Service, Runnable, AutoCloseable {
@Override
public void run() {
setState(ServiceState.RUNNING);
this.receiveCancellations.addFirst(this.executionKilledQueue.receive(executionKilled -> {
if (executionKilled == null || !executionKilled.isLeft()) {
return;
@@ -232,6 +231,7 @@ public class Worker implements Service, Runnable, AutoCloseable {
});
}
));
setState(ServiceState.RUNNING);
}
private void setState(final ServiceState state) {

4
core/src/main/java/io/kestra/core/schedulers/DefaultScheduleContext.java
View File

@@ -1,4 +0,0 @@
package io.kestra.core.schedulers;
// For tests purpose
public class DefaultScheduleContext implements ScheduleContextInterface {}

94
core/src/main/java/io/kestra/core/schedulers/DefaultScheduler.java
View File

@@ -1,94 +0,0 @@
package io.kestra.core.schedulers;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.flows.Flow;
import io.kestra.core.models.triggers.Trigger;
import io.kestra.core.queues.QueueFactoryInterface;
import io.kestra.core.queues.QueueInterface;
import io.kestra.core.repositories.FlowRepositoryInterface;
import io.kestra.core.services.ConditionService;
import io.kestra.core.services.FlowListenersInterface;
import io.kestra.core.utils.Await;
import io.micronaut.context.ApplicationContext;
import io.micronaut.inject.qualifiers.Qualifiers;
import jakarta.inject.Inject;
import jakarta.inject.Singleton;
import lombok.extern.slf4j.Slf4j;
import java.time.Duration;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
@Slf4j
@Singleton
//TODO maybe move it to the MemoryRunner ?
public class DefaultScheduler extends AbstractScheduler {
private final Map<String, Trigger> watchingTrigger = new ConcurrentHashMap<>();
private final ConditionService conditionService;
private final FlowRepositoryInterface flowRepository;
@Inject
public DefaultScheduler(
ApplicationContext applicationContext,
FlowListenersInterface flowListeners,
SchedulerTriggerStateInterface triggerState
) {
super(applicationContext, flowListeners);
this.triggerState = triggerState;
this.conditionService = applicationContext.getBean(ConditionService.class);
this.flowRepository = applicationContext.getBean(FlowRepositoryInterface.class);
}
@SuppressWarnings("unchecked")
@Override
public void run() {
QueueInterface<Execution> executionQueue = applicationContext.getBean(QueueInterface.class, Qualifiers.byName(QueueFactoryInterface.EXECUTION_NAMED));
QueueInterface<Trigger> triggerQueue = applicationContext.getBean(QueueInterface.class, Qualifiers.byName(QueueFactoryInterface.TRIGGER_NAMED));
this.receiveCancellations.addFirst(executionQueue.receive(either -> {
if (either.isRight()) {
log.error("Unable to deserialize and execution: {}", either.getRight().getMessage());
return;
}
Execution execution = either.getLeft();
if (execution.getTrigger() != null) {
Trigger trigger = Await.until(() -> watchingTrigger.get(execution.getId()), Duration.ofSeconds(5));
var flow = flowRepository.findById(execution.getTenantId(), execution.getNamespace(), execution.getFlowId()).orElse(null);
if (execution.isDeleted() || conditionService.isTerminatedWithListeners(flow, execution)) {
triggerState.update(trigger.resetExecution(execution.getState().getCurrent()));
watchingTrigger.remove(execution.getId());
} else {
triggerState.update(Trigger.of(execution, trigger));
}
}
}));
this.receiveCancellations.addFirst(triggerQueue.receive(either -> {
if (either.isRight()) {
log.error("Unable to deserialize a trigger: {}", either.getRight().getMessage());
return;
}
Trigger trigger = either.getLeft();
if (trigger != null && trigger.getExecutionId() != null) {
this.watchingTrigger.put(trigger.getExecutionId(), trigger);
}
}));
super.run();
}
@Override
public void handleNext(List<Flow> flows, ZonedDateTime now, BiConsumer<List<Trigger>, ScheduleContextInterface> consumer) {
List<Trigger> triggers = triggerState.findAllForAllTenants().stream().filter(trigger -> trigger.getNextExecutionDate() == null || trigger.getNextExecutionDate().isBefore(now)).toList();
DefaultScheduleContext schedulerContext = new DefaultScheduleContext();
consumer.accept(triggers, schedulerContext);
}
}

4
core/src/test/java/io/kestra/core/docs/DocumentationGeneratorTest.java
View File

@@ -10,7 +10,7 @@ import io.kestra.plugin.core.debug.Return;
import io.kestra.plugin.core.flow.Dag;
import io.kestra.plugin.core.flow.Subflow;
import io.kestra.plugin.core.state.Set;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -25,7 +25,7 @@ import java.util.Objects;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class DocumentationGeneratorTest {
@Inject
JsonSchemaGenerator jsonSchemaGenerator;

4
core/src/test/java/io/kestra/core/docs/JsonSchemaGeneratorTest.java
View File

@@ -16,7 +16,7 @@ import io.kestra.plugin.core.debug.Echo;
import io.kestra.plugin.core.debug.Return;
import io.kestra.plugin.core.flow.Dag;
import io.kestra.plugin.core.log.Log;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.inject.Inject;
import lombok.Builder;
@@ -37,7 +37,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class JsonSchemaGeneratorTest {

43
core/src/test/java/io/kestra/core/junit/annotations/KestraTest.java Normal file
View File

@@ -0,0 +1,43 @@
package io.kestra.core.junit.annotations;
import io.kestra.core.junit.extensions.KestraTestExtension;
import io.micronaut.context.ApplicationContextBuilder;
import io.micronaut.context.annotation.Executable;
import io.micronaut.context.annotation.Factory;
import io.micronaut.context.annotation.Requires;
import io.micronaut.test.annotation.TransactionMode;
import io.micronaut.test.condition.TestActiveCondition;
import org.junit.jupiter.api.extension.ExtendWith;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE, ElementType.TYPE})
@ExtendWith(KestraTestExtension.class)
@Factory
@Inherited
@Requires(condition = TestActiveCondition.class)
@Executable
public @interface KestraTest {
Class<?> application() default void.class;
String[] environments() default {};
String[] packages() default {};
String[] propertySources() default {};
boolean rollback() default true;
boolean transactional() default false;
boolean rebuildContext() default false;
Class<? extends ApplicationContextBuilder>[] contextBuilder() default {};
TransactionMode transactionMode() default TransactionMode.SEPARATE_TRANSACTIONS;
boolean startApplication() default true;
boolean resolveParameters() default true;
}

41
core/src/test/java/io/kestra/core/junit/extensions/KestraTestExtension.java Normal file
View File

@@ -0,0 +1,41 @@
package io.kestra.core.junit.extensions;
import io.kestra.core.junit.annotations.KestraTest;
import io.micronaut.test.annotation.MicronautTestValue;
import io.micronaut.test.extensions.junit5.MicronautJunit5Extension;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.platform.commons.support.AnnotationSupport;
public class KestraTestExtension extends MicronautJunit5Extension {
private static final ExtensionContext.Namespace NAMESPACE = ExtensionContext.Namespace.create(KestraTestExtension.class);
@Override
protected MicronautTestValue buildMicronautTestValue(Class<?> testClass) {
return AnnotationSupport
.findAnnotation(testClass, KestraTest.class)
.map(kestraTestAnnotation -> new MicronautTestValue(
kestraTestAnnotation.application(),
kestraTestAnnotation.environments(),
kestraTestAnnotation.packages(),
kestraTestAnnotation.propertySources(),
kestraTestAnnotation.rollback(),
kestraTestAnnotation.transactional(),
kestraTestAnnotation.rebuildContext(),
kestraTestAnnotation.contextBuilder(),
kestraTestAnnotation.transactionMode(),
kestraTestAnnotation.startApplication(),
kestraTestAnnotation.resolveParameters()
))
.orElse(null);
}
@Override
protected ExtensionContext.Store getStore(ExtensionContext context) {
return context.getRoot().getStore(NAMESPACE);
}
@Override
protected boolean hasExpectedAnnotations(Class<?> testClass) {
return AnnotationSupport.isAnnotated(testClass, KestraTest.class);
}
}

4
core/src/test/java/io/kestra/core/models/flows/FlowTest.java
View File

@@ -6,7 +6,7 @@ import io.kestra.core.models.validations.ModelValidator;
import io.kestra.core.serializers.YamlFlowParser;
import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -19,7 +19,7 @@ import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class FlowTest {
@Inject
YamlFlowParser yamlFlowParser = new YamlFlowParser();

4
core/src/test/java/io/kestra/core/models/tasks/runners/AbstractTaskRunnerTest.java
View File

@@ -11,7 +11,7 @@ import io.kestra.core.runners.RunContext;
import io.kestra.core.runners.RunContextFactory;
import io.kestra.core.storages.StorageInterface;
import io.kestra.core.utils.IdUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
@@ -28,7 +28,7 @@ import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
public abstract class AbstractTaskRunnerTest {
@Inject private RunContextFactory runContextFactory;
@Inject private StorageInterface storage;

4
core/src/test/java/io/kestra/core/models/tasks/runners/ScriptServiceTest.java
View File

@@ -9,7 +9,7 @@ import io.kestra.core.models.tasks.Task;
import io.kestra.core.models.tasks.runners.ScriptService;
import io.kestra.core.runners.RunContext;
import io.kestra.core.runners.RunContextFactory;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -26,7 +26,7 @@ import java.util.concurrent.atomic.AtomicReference;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class ScriptServiceTest {
@Inject private RunContextFactory runContextFactory;

4
core/src/test/java/io/kestra/core/models/tasks/runners/TaskRunnerTest.java
View File

@@ -4,7 +4,7 @@ import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.RunContext;
import io.kestra.core.runners.RunContextFactory;
import io.micronaut.context.ApplicationContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -17,7 +17,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
public class TaskRunnerTest {
public static final String ADDITIONAL_VAR_KEY = "additionalVarKey";
public static final String ADDITIONAL_ENV_KEY = "ADDITIONAL_ENV_KEY";

4
core/src/test/java/io/kestra/core/models/triggers/multipleflows/AbstractMultipleConditionStorageTest.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.models.triggers.multipleflows;
import com.google.common.collect.ImmutableMap;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.apache.commons.lang3.tuple.Pair;
import org.junit.jupiter.api.Test;
import io.kestra.plugin.core.condition.ExecutionFlowCondition;
@@ -20,7 +20,7 @@ import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractMultipleConditionStorageTest {
private static final String NAMESPACE = "io.kestra.unit";

4
core/src/test/java/io/kestra/core/plugins/PluginConfigurationTest.java
View File

@@ -1,6 +1,6 @@
package io.kestra.core.plugins;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@@ -12,7 +12,7 @@ import java.util.stream.IntStream;
import static org.hamcrest.CoreMatchers.hasItem;
import static org.hamcrest.MatcherAssert.assertThat;
@MicronautTest
@KestraTest
class PluginConfigurationTest {
@Inject

4
core/src/test/java/io/kestra/core/repositories/AbstractExecutionRepositoryTest.java
View File

@@ -14,7 +14,7 @@ import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.IdUtils;
import io.micronaut.data.model.Pageable;
import io.micronaut.data.model.Sort;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -29,7 +29,7 @@ import static org.hamcrest.Matchers.*;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractExecutionRepositoryTest {
public static final String NAMESPACE = "io.kestra.unittest";
public static final String FLOW = "full";

4
core/src/test/java/io/kestra/core/repositories/AbstractExecutionServiceTest.java
View File

@@ -11,7 +11,7 @@ import io.kestra.core.services.ExecutionService;
import io.kestra.core.storages.StorageInterface;
import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.IdUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import org.slf4j.event.Level;
@@ -29,7 +29,7 @@ import java.util.Objects;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractExecutionServiceTest {
@Inject
ExecutionService executionService;

309
core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
View File

@@ -26,7 +26,7 @@ import io.kestra.core.utils.TestsUtils;
import io.micronaut.context.event.ApplicationEventListener;
import io.micronaut.data.model.Pageable;
import io.micronaut.data.model.Sort;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import jakarta.inject.Singleton;
@@ -47,7 +47,8 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
@MicronautTest(transactional = false)
// If some counts are wrong in this test it means that one of the tests is not properly deleting what it created
@KestraTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public abstract class AbstractFlowRepositoryTest {
@Inject
@@ -85,14 +86,17 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder()
.revision(3)
.build();
flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
flow = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
try {
Optional<Flow> full = flowRepository.findById(null, flow.getNamespace(), flow.getId());
assertThat(full.isPresent(), is(true));
assertThat(full.get().getRevision(), is(1));
Optional<Flow> full = flowRepository.findById(null, flow.getNamespace(), flow.getId());
assertThat(full.isPresent(), is(true));
assertThat(full.get().getRevision(), is(1));
full = flowRepository.findById(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
full = flowRepository.findById(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
} finally {
deleteFlow(flow);
}
}
@Test
@@ -100,14 +104,17 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder()
.revision(3)
.build();
flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
flow = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
try {
Optional<Flow> full = flowRepository.findByIdWithoutAcl(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
assertThat(full.get().getRevision(), is(1));
Optional<Flow> full = flowRepository.findByIdWithoutAcl(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
assertThat(full.get().getRevision(), is(1));
full = flowRepository.findByIdWithoutAcl(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
full = flowRepository.findByIdWithoutAcl(null, flow.getNamespace(), flow.getId(), Optional.empty());
assertThat(full.isPresent(), is(true));
} finally {
deleteFlow(flow);
}
}
@Test
@@ -115,16 +122,20 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder()
.revision(3)
.build();
flowRepository.create(flow, "# comment\n" + flow.generateSource(), pluginDefaultService.injectDefaults(flow));
flow = flowRepository.create(flow, "# comment\n" + flow.generateSource(), pluginDefaultService.injectDefaults(flow));
Optional<FlowWithSource> full = flowRepository.findByIdWithSource(null, flow.getNamespace(), flow.getId());
assertThat(full.isPresent(), is(true));
try {
Optional<FlowWithSource> full = flowRepository.findByIdWithSource(null, flow.getNamespace(), flow.getId());
assertThat(full.isPresent(), is(true));
full.ifPresent(current -> {
assertThat(full.get().getRevision(), is(1));
assertThat(full.get().getSource(), containsString("# comment"));
assertThat(full.get().getSource(), not(containsString("revision:")));
});
full.ifPresent(current -> {
assertThat(full.get().getRevision(), is(1));
assertThat(full.get().getSource(), containsString("# comment"));
assertThat(full.get().getSource(), not(containsString("revision:")));
});
} finally {
deleteFlow(flow);
}
}
@Test
@@ -140,57 +151,60 @@ public abstract class AbstractFlowRepositoryTest {
// create with repository
FlowWithSource flow = flowRepository.create(first, first.generateSource(), pluginDefaultService.injectDefaults(first));
// submit new one, no change
Flow notSaved = flowRepository.update(flow, flow, first.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(notSaved.getRevision(), is(flow.getRevision()));
List<FlowWithSource> revisions;
try {
// submit new one, no change
Flow notSaved = flowRepository.update(flow, flow, first.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(notSaved.getRevision(), is(flow.getRevision()));
// submit new one with change
Flow flowRev2 = Flow.builder()
.id(flowId)
.namespace("io.kestra.unittest")
.tasks(Collections.singletonList(
Log.builder()
.id(IdUtils.create())
.type(Log.class.getName())
.message("Hello World")
.build()
))
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.build();
// submit new one with change
Flow flowRev2 = Flow.builder()
.id(flowId)
.namespace("io.kestra.unittest")
.tasks(Collections.singletonList(
Log.builder()
.id(IdUtils.create())
.type(Log.class.getName())
.message("Hello World")
.build()
))
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.build();
// revision is incremented
FlowWithSource incremented = flowRepository.update(flowRev2, flow, flowRev2.generateSource(), pluginDefaultService.injectDefaults(flowRev2));
assertThat(incremented.getRevision(), is(2));
// revision is incremented
FlowWithSource incremented = flowRepository.update(flowRev2, flow, flowRev2.generateSource(), pluginDefaultService.injectDefaults(flowRev2));
assertThat(incremented.getRevision(), is(2));
// revision is well saved
List<FlowWithSource> revisions = flowRepository.findRevisions(null, flow.getNamespace(), flow.getId());
assertThat(revisions.size(), is(2));
// revision is well saved
revisions = flowRepository.findRevisions(null, flow.getNamespace(), flow.getId());
assertThat(revisions.size(), is(2));
// submit the same one serialized, no changed
FlowWithSource incremented2 = flowRepository.update(
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flowRev2), Flow.class),
flowRev2,
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flowRev2), Flow.class).generateSource(),
pluginDefaultService.injectDefaults(flowRev2)
);
assertThat(incremented2.getRevision(), is(2));
// submit the same one serialized, no changed
FlowWithSource incremented2 = flowRepository.update(
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flowRev2), Flow.class),
flowRev2,
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flowRev2), Flow.class).generateSource(),
pluginDefaultService.injectDefaults(flowRev2)
);
assertThat(incremented2.getRevision(), is(2));
// resubmit first one, revision is incremented
FlowWithSource incremented3 = flowRepository.update(
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class),
flowRev2,
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class).generateSource(),
pluginDefaultService.injectDefaults(JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class))
);
assertThat(incremented3.getRevision(), is(3));
// delete
flowRepository.delete(incremented3);
// resubmit first one, revision is incremented
FlowWithSource incremented3 = flowRepository.update(
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class),
flowRev2,
JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class).generateSource(),
pluginDefaultService.injectDefaults(JacksonMapper.ofJson().readValue(JacksonMapper.ofJson().writeValueAsString(flow.toFlow()), Flow.class))
);
assertThat(incremented3.getRevision(), is(3));
} finally {
deleteFlow(flow);
}
// revisions is still findable after delete
revisions = flowRepository.findRevisions(null, flow.getNamespace(), flow.getId());
assertThat(revisions.size(), is(4));
Optional<Flow> findDeleted = flowRepository.findById(
null,
flow.getNamespace(),
@@ -203,7 +217,11 @@ public abstract class AbstractFlowRepositoryTest {
// recreate the first one, we have a new revision
Flow incremented4 = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(incremented4.getRevision(), is(5));
try {
assertThat(incremented4.getRevision(), is(5));
} finally {
deleteFlow(incremented4);
}
}
@Test
@@ -211,7 +229,11 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder().revision(12).build();
Flow save = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(save.getRevision(), is(1));
try {
assertThat(save.getRevision(), is(1));
} finally {
deleteFlow(save);
}
}
@Test
@@ -219,9 +241,12 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder().build();
Flow save = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(save.getRevision(), is(1));
try {
assertThat(save.getRevision(), is(1));
} finally {
deleteFlow(save);
}
flowRepository.delete(save);
}
@Test
@@ -268,12 +293,16 @@ public abstract class AbstractFlowRepositoryTest {
.revision(3)
.build();
String flowSource = "# comment\n" + flow.generateSource();
flowRepository.create(flow, flowSource, pluginDefaultService.injectDefaults(flow));
flow = flowRepository.create(flow, flowSource, pluginDefaultService.injectDefaults(flow));
List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(null, flow.getNamespace());
assertThat((long) save.size(), is(1L));
try {
List<FlowWithSource> save = flowRepository.findByNamespaceWithSource(null, flow.getNamespace());
assertThat((long) save.size(), is(1L));
assertThat(save.get(0).getSource(), is(FlowService.cleanupSource(flowSource)));
assertThat(save.get(0).getSource(), is(FlowService.cleanupSource(flowSource)));
} finally {
deleteFlow(flow);
}
}
@Test
@@ -284,16 +313,16 @@ public abstract class AbstractFlowRepositoryTest {
save = flowRepository.find(Pageable.from(1, (int) Helpers.FLOWS_COUNT + 1, Sort.UNSORTED), null, null, null, null);
assertThat((long) save.size(), is(Helpers.FLOWS_COUNT));
save = flowRepository.find(Pageable.from(1),null, null, "io.kestra.tests.minimal.bis", Collections.emptyMap());
save = flowRepository.find(Pageable.from(1), null, null, "io.kestra.tests.minimal.bis", Collections.emptyMap());
assertThat((long) save.size(), is(1L));
save = flowRepository.find(Pageable.from(1, 100, Sort.UNSORTED), null, null, null, Map.of("country", "FR"));
assertThat(save.size(), is(1));
save = flowRepository.find(Pageable.from(1),null, null, "io.kestra.tests", Map.of("key2", "value2"));
save = flowRepository.find(Pageable.from(1), null, null, "io.kestra.tests", Map.of("key2", "value2"));
assertThat((long) save.size(), is(1L));
save = flowRepository.find(Pageable.from(1),null, null, "io.kestra.tests", Map.of("key1", "value2"));
save = flowRepository.find(Pageable.from(1), null, null, "io.kestra.tests", Map.of("key1", "value2"));
assertThat((long) save.size(), is(0L));
}
@@ -314,7 +343,13 @@ public abstract class AbstractFlowRepositoryTest {
Flow flow = builder().build();
Flow save = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(flowRepository.findById(null, save.getNamespace(), save.getId()).isPresent(), is(true));
try {
assertThat(flowRepository.findById(null, save.getNamespace(), save.getId()).isPresent(), is(true));
} catch (Throwable e) {
deleteFlow(save);
throw e;
}
Flow delete = flowRepository.delete(save);
@@ -338,24 +373,26 @@ public abstract class AbstractFlowRepositoryTest {
Flow save = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
try {
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
Flow update = Flow.builder()
.id(IdUtils.create())
.namespace("io.kestra.unittest2")
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format("test").build()))
.build();
;
Flow update = Flow.builder()
.id(IdUtils.create())
.namespace("io.kestra.unittest2")
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format("test").build()))
.build();
;
ConstraintViolationException e = assertThrows(
ConstraintViolationException.class,
() -> flowRepository.update(update, flow, update.generateSource(), pluginDefaultService.injectDefaults(update))
);
ConstraintViolationException e = assertThrows(
ConstraintViolationException.class,
() -> flowRepository.update(update, flow, update.generateSource(), pluginDefaultService.injectDefaults(update))
);
assertThat(e.getConstraintViolations().size(), is(2));
flowRepository.delete(save);
assertThat(e.getConstraintViolations().size(), is(2));
} finally {
deleteFlow(save);
}
}
@Test
@@ -372,20 +409,22 @@ public abstract class AbstractFlowRepositoryTest {
.tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format("test").build()))
.build();
flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
flow = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
try {
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
Flow update = Flow.builder()
.id(flowId)
.namespace("io.kestra.unittest")
.tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format("test").build()))
.build();
;
Flow update = Flow.builder()
.id(flowId)
.namespace("io.kestra.unittest")
.tasks(Collections.singletonList(Return.builder().id("test").type(Return.class.getName()).format("test").build()))
.build();
;
Flow updated = flowRepository.update(update, flow, update.generateSource(), pluginDefaultService.injectDefaults(update));
assertThat(updated.getTriggers(), is(nullValue()));
flowRepository.delete(updated);
Flow updated = flowRepository.update(update, flow, update.generateSource(), pluginDefaultService.injectDefaults(update));
assertThat(updated.getTriggers(), is(nullValue()));
} finally {
deleteFlow(flow);
}
Await.until(() -> FlowListener.getEmits().size() == 3, Duration.ofMillis(100), Duration.ofSeconds(5));
assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count(), is(1L));
@@ -409,10 +448,11 @@ public abstract class AbstractFlowRepositoryTest {
.build();
Flow save = flowRepository.create(flow, flow.generateSource(), pluginDefaultService.injectDefaults(flow));
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
flowRepository.delete(save);
try {
assertThat(flowRepository.findById(null, flow.getNamespace(), flow.getId()).isPresent(), is(true));
} finally {
deleteFlow(save);
}
Await.until(() -> FlowListener.getEmits().size() == 2, Duration.ofMillis(100), Duration.ofSeconds(5));
assertThat(FlowListener.getEmits().stream().filter(r -> r.getType() == CrudEventType.CREATE).count(), is(1L));
@@ -446,17 +486,21 @@ public abstract class AbstractFlowRepositoryTest {
.tasks(Collections.singletonList(templateSpy))
.build();
flowRepository.create(
flow = flowRepository.create(
flow,
flow.generateSource(),
flow
);
Optional<Flow> found = flowRepository.findById(null, flow.getNamespace(), flow.getId());
try {
Optional<Flow> found = flowRepository.findById(null, flow.getNamespace(), flow.getId());
assertThat(found.isPresent(), is(true));
assertThat(found.get() instanceof FlowWithException, is(true));
assertThat(((FlowWithException) found.get()).getException(), containsString("Templates are disabled"));
assertThat(found.isPresent(), is(true));
assertThat(found.get() instanceof FlowWithException, is(true));
assertThat(((FlowWithException) found.get()).getException(), containsString("Templates are disabled"));
} finally {
deleteFlow(flow);
}
}
@Test
@@ -476,24 +520,33 @@ public abstract class AbstractFlowRepositoryTest {
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("a").build()))
.build();
// create with repository
flowRepository.create(first, first.generateSource(), pluginDefaultService.injectDefaults(first));
assertThat(flowRepository.lastRevision(tenantId, namespace, flowId), is(1));
first = flowRepository.create(first, first.generateSource(), pluginDefaultService.injectDefaults(first));
try {
assertThat(flowRepository.lastRevision(tenantId, namespace, flowId), is(1));
// submit new one with change
// submit new one with change
Flow flowRev2 = first.toBuilder()
.tasks(Collections.singletonList(
Log.builder()
.id(IdUtils.create())
.type(Log.class.getName())
.message("Hello World")
.build()
))
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.build();
Flow flowRev2 = first.toBuilder()
.tasks(Collections.singletonList(
Log.builder()
.id(IdUtils.create())
.type(Log.class.getName())
.message("Hello World")
.build()
))
.inputs(ImmutableList.of(StringInput.builder().type(Type.STRING).id("b").build()))
.build();
flowRepository.update(flowRev2, first, flowRev2.generateSource(), pluginDefaultService.injectDefaults(flowRev2));
assertThat(flowRepository.lastRevision(tenantId, namespace, flowId), is(2));
first = flowRepository.update(flowRev2, first, flowRev2.generateSource(), pluginDefaultService.injectDefaults(flowRev2));
assertThat(flowRepository.lastRevision(tenantId, namespace, flowId), is(2));
} finally {
deleteFlow(first);
}
}
private void deleteFlow(Flow flow) {
Integer revision = flowRepository.lastRevision(flow.getTenantId(), flow.getNamespace(), flow.getId());
flowRepository.delete(flow.toBuilder().revision(revision).build());
}
@Singleton

4
core/src/test/java/io/kestra/core/repositories/AbstractFlowTopologyRepositoryTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.repositories;
import io.kestra.core.models.topologies.FlowNode;
import io.kestra.core.models.topologies.FlowRelation;
import io.kestra.core.models.topologies.FlowTopology;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -12,7 +12,7 @@ import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractFlowTopologyRepositoryTest {
@Inject
private FlowTopologyRepositoryInterface flowTopologyRepository;

4
core/src/test/java/io/kestra/core/repositories/AbstractLogRepositoryTest.java
View File

@@ -5,7 +5,7 @@ import io.kestra.core.models.executions.LogEntry;
import io.kestra.core.models.executions.statistics.LogStatistics;
import io.kestra.core.utils.IdUtils;
import io.micronaut.data.model.Pageable;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import org.slf4j.event.Level;
@@ -16,7 +16,7 @@ import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractLogRepositoryTest {
@Inject
protected LogRepositoryInterface logRepository;

4
core/src/test/java/io/kestra/core/repositories/AbstractMetricRepositoryTest.java
View File

@@ -7,7 +7,7 @@ import io.kestra.core.models.executions.metrics.Counter;
import io.kestra.core.models.executions.metrics.MetricAggregations;
import io.kestra.core.models.executions.metrics.Timer;
import io.micronaut.data.model.Pageable;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -18,7 +18,7 @@ import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractMetricRepositoryTest {
@Inject
protected MetricRepositoryInterface metricRepository;

6
core/src/test/java/io/kestra/core/repositories/AbstracSettingRepositoryTest.java → core/src/test/java/io/kestra/core/repositories/AbstractSettingRepositoryTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.repositories;
import io.kestra.core.models.Setting;
import io.kestra.core.utils.IdUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -12,8 +12,8 @@ import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
public abstract class AbstracSettingRepositoryTest {
@KestraTest
public abstract class AbstractSettingRepositoryTest {
@Inject
protected SettingRepositoryInterface settingRepository;

4
core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java
View File

@@ -7,7 +7,7 @@ import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.IdUtils;
import io.micronaut.context.event.ApplicationEventListener;
import io.micronaut.data.model.Pageable;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Singleton;
import org.junit.jupiter.api.BeforeEach;
@@ -23,7 +23,7 @@ import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractTemplateRepositoryTest {
@Inject
protected TemplateRepositoryInterface templateRepository;

4
core/src/test/java/io/kestra/core/repositories/AbstractTriggerRepositoryTest.java
View File

@@ -4,7 +4,7 @@ import io.kestra.core.models.triggers.Trigger;
import io.kestra.core.utils.IdUtils;
import io.micronaut.data.model.Pageable;
import io.micronaut.data.model.Sort;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -15,7 +15,7 @@ import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
public abstract class AbstractTriggerRepositoryTest {
private static final String TEST_NAMESPACE = "io.kestra.unittest";

7
core/src/test/java/io/kestra/core/runners/AbstractMemoryRunnerTest.java
View File

@@ -1,19 +1,18 @@
package io.kestra.core.runners;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import io.kestra.core.utils.TestsUtils;
import io.kestra.core.repositories.LocalFlowRepositoryLoader;
import io.kestra.runner.memory.MemoryRunner;
import org.junit.jupiter.api.BeforeEach;
import jakarta.inject.Inject;
import java.io.IOException;
import java.net.URISyntaxException;
@MicronautTest
@KestraTest
abstract public class AbstractMemoryRunnerTest {
@Inject
protected MemoryRunner runner;
protected StandAloneRunner runner;
@Inject
protected RunnerUtils runnerUtils;

4
core/src/test/java/io/kestra/core/runners/FilesServiceTest.java
View File

@@ -1,6 +1,6 @@
package io.kestra.core.runners;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.apache.commons.io.FileUtils;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class FilesServiceTest {
@Inject
private RunContextFactory runContextFactory;

4
core/src/test/java/io/kestra/core/runners/FlowListenersTest.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.runners;
import io.kestra.core.services.PluginDefaultService;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import lombok.SneakyThrows;
import io.kestra.core.models.flows.Flow;
import io.kestra.core.repositories.FlowRepositoryInterface;
@@ -18,7 +18,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest(transactional = false)
@KestraTest
abstract public class FlowListenersTest {
@Inject
protected FlowRepositoryInterface flowRepository;

4
core/src/test/java/io/kestra/core/runners/NamespaceFilesServiceTest.java
View File

@@ -5,7 +5,7 @@ import io.kestra.core.storages.StorageContext;
import io.kestra.core.storages.StorageInterface;
import io.kestra.core.utils.IdUtils;
import io.micronaut.core.annotation.Nullable;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.apache.commons.io.FileUtils;
import org.junit.jupiter.api.Test;
@@ -22,7 +22,7 @@ import static io.kestra.core.utils.Rethrow.throwFunction;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class NamespaceFilesServiceTest {
@Inject
StorageInterface storageInterface;

4
core/src/test/java/io/kestra/core/runners/NoEncryptionConfiguredTest.java
View File

@@ -7,7 +7,7 @@ import io.kestra.core.models.flows.State;
import io.kestra.core.models.tasks.common.EncryptedString;
import io.kestra.core.repositories.FlowRepositoryInterface;
import io.micronaut.core.annotation.NonNull;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import io.micronaut.test.support.TestPropertyProvider;
import jakarta.inject.Inject;
import jakarta.validation.ConstraintViolationException;
@@ -23,7 +23,7 @@ import static org.hamcrest.Matchers.*;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class NoEncryptionConfiguredTest extends AbstractMemoryRunnerTest implements TestPropertyProvider {

4
core/src/test/java/io/kestra/core/runners/RunContextLoggerTest.java
View File

@@ -6,7 +6,7 @@ import io.kestra.core.models.flows.Flow;
import io.kestra.core.queues.QueueFactoryInterface;
import io.kestra.core.queues.QueueInterface;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.junit.jupiter.api.Test;
@@ -21,7 +21,7 @@ import java.util.concurrent.CopyOnWriteArrayList;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class RunContextLoggerTest {
@Inject
@Named(QueueFactoryInterface.WORKERTASKLOG_NAMED)

4
core/src/test/java/io/kestra/core/runners/VariableRendererTest.java
View File

@@ -2,14 +2,14 @@ package io.kestra.core.runners;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.micronaut.context.ApplicationContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Map;
@MicronautTest
@KestraTest
class VariableRendererTest {
@Inject

4
core/src/test/java/io/kestra/core/runners/WorkerTest.java
View File

@@ -16,7 +16,7 @@ import io.kestra.core.utils.Await;
import io.kestra.core.utils.IdUtils;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.context.ApplicationContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.junit.jupiter.api.Assertions;
@@ -35,7 +35,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
@MicronautTest
@KestraTest
class WorkerTest {
@Inject
ApplicationContext applicationContext;

4
core/src/test/java/io/kestra/core/runners/pebble/PebbleVariableRendererTest.java
View File

@@ -6,7 +6,7 @@ import com.google.common.collect.ImmutableSet;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.kestra.core.utils.Rethrow;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.time.ZonedDateTime;
@@ -19,7 +19,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class PebbleVariableRendererTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/RecursivePebbleVariableRendererTest.java
View File

@@ -6,7 +6,7 @@ import com.google.common.collect.ImmutableSet;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.context.annotation.Property;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -17,7 +17,7 @@ import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
@Property(name = "kestra.variables.recursive-rendering", value = "true")
class RecursivePebbleVariableRendererTest {
@Inject

4
core/src/test/java/io/kestra/core/runners/pebble/expression/NullCoalescingExpressionTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.expression;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import jakarta.inject.Inject;
@@ -14,7 +14,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class NullCoalescingExpressionTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/ChunkFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.kestra.core.utils.Rethrow;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
@@ -14,7 +14,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class ChunkFilterTest {
@Inject
VariableRenderer variableRenderer;

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

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.time.ZoneId;
@@ -18,7 +18,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class DateFilterTest {
public static final ZonedDateTime NOW = ZonedDateTime.parse("2013-09-08T16:19:12.123456+01");

4
core/src/test/java/io/kestra/core/runners/pebble/filters/EndsWithFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class EndsWithFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/EscapeCharFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
@@ -16,7 +16,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class EscapeCharFilterTest {
@Inject
private VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/FlattenFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
public class FlattenFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/IndentFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class IndentFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/JqFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -17,7 +17,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class JqFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/JsonFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.time.ZoneId;
@@ -17,7 +17,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.hamcrest.Matchers.endsWith;
@MicronautTest
@KestraTest
class JsonFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/KeysFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -16,7 +16,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class KeysFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/NindentFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class NindentFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/NumberFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
@@ -15,7 +15,7 @@ import java.util.stream.Stream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class NumberFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/ReplaceFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -16,7 +16,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class ReplaceFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/SlugifyFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class SlugifyFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/StartsWithFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class StartsWithFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/SubstringFilterTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class SubstringFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/UrlDecodeFilter.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.filters;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class UrlDecodeFilter {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/filters/YamlFilterTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.filters;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -16,7 +16,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class YamlFilterTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/EncryptDecryptFunctionTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.runners.pebble.functions;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.context.annotation.Value;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -15,7 +15,7 @@ import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest(rebuildContext = true)
@KestraTest
class EncryptDecryptFunctionTest {
@Inject
private VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/JsonFunctionTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.functions;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.Map;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class JsonFunctionTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/PrintContextFunctionTest.java
View File

@@ -4,7 +4,7 @@ import com.fasterxml.jackson.core.JsonProcessingException;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.kestra.core.serializers.JacksonMapper;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -14,7 +14,7 @@ import java.util.Map;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class PrintContextFunctionTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/ReadFileFunctionTest.java
View File

@@ -6,7 +6,7 @@ import io.kestra.core.storages.StorageContext;
import io.kestra.core.storages.StorageInterface;
import io.kestra.core.utils.IdUtils;
import io.micronaut.context.annotation.Property;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import io.pebbletemplates.pebble.error.PebbleException;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Disabled;
@@ -23,7 +23,7 @@ import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest(rebuildContext = true)
@KestraTest
@Property(name="kestra.server-type", value="WORKER")
class ReadFileFunctionTest {
@Inject

4
core/src/test/java/io/kestra/core/runners/pebble/functions/RenderFunctionTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.runners.pebble.functions;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.time.*;
import java.util.HashMap;
import java.util.Map;
@MicronautTest
@KestraTest
class RenderFunctionTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/RenderOncerFunctionTest.java
View File

@@ -2,14 +2,14 @@ package io.kestra.core.runners.pebble.functions;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.util.Map;
@MicronautTest
@KestraTest
class RenderOncerFunctionTest {
@Inject
VariableRenderer variableRenderer;

4
core/src/test/java/io/kestra/core/runners/pebble/functions/YamlFunctionTest.java
View File

@@ -3,14 +3,14 @@ package io.kestra.core.runners.pebble.functions;
import com.google.common.collect.ImmutableMap;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.runners.VariableRenderer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class YamlFunctionTest {
@Inject
VariableRenderer variableRenderer;

25
core/src/test/java/io/kestra/core/schedulers/AbstractSchedulerTest.java
View File

@@ -7,6 +7,7 @@ import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.executions.ExecutionTrigger;
import io.kestra.core.models.flows.*;
import io.kestra.core.models.flows.input.StringInput;
import io.kestra.core.models.tasks.WorkerGroup;
import io.kestra.core.models.triggers.AbstractTrigger;
import io.kestra.core.models.triggers.PollingTriggerInterface;
import io.kestra.core.models.triggers.TriggerContext;
@@ -15,7 +16,7 @@ import io.kestra.core.queues.QueueInterface;
import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.IdUtils;
import io.micronaut.context.ApplicationContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import lombok.*;
@@ -24,9 +25,10 @@ import lombok.experimental.SuperBuilder;
import java.time.Duration;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@MicronautTest(transactional = false, rebuildContext = true) // rebuild context to lower possible flaky tests
@KestraTest
abstract public class AbstractSchedulerTest {
@Inject
protected ApplicationContext applicationContext;
@@ -35,6 +37,25 @@ abstract public class AbstractSchedulerTest {
@Named(QueueFactoryInterface.EXECUTION_NAMED)
protected QueueInterface<Execution> executionQueue;
public static Flow createThreadFlow() {
return createThreadFlow(null);
}
public static Flow createThreadFlow(String workerGroup) {
UnitTest schedule = UnitTest.builder()
.id("sleep")
.type(UnitTest.class.getName())
.workerGroup(workerGroup == null ? null : new WorkerGroup(workerGroup))
.build();
return createFlow(Collections.singletonList(schedule), List.of(
PluginDefault.builder()
.type(UnitTest.class.getName())
.values(Map.of("defaultInjected", "done"))
.build()
));
}
protected static Flow createFlow(List<AbstractTrigger> triggers) {
return createFlow(triggers, null);
}

9
core/src/test/java/io/kestra/core/schedulers/SchedulerConditionTest.java
View File

@@ -1,6 +1,7 @@
package io.kestra.core.schedulers;
import io.kestra.core.utils.TestsUtils;
import io.kestra.jdbc.runner.JdbcScheduler;
import io.kestra.plugin.core.condition.DayWeekInMonthCondition;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.flows.Flow;
@@ -75,12 +76,12 @@ class SchedulerConditionTest extends AbstractSchedulerTest {
.flows();
// scheduler
try (AbstractScheduler scheduler = new DefaultScheduler(
try (AbstractScheduler scheduler = new JdbcScheduler(
applicationContext,
flowListenersServiceSpy,
triggerState)) {
flowListenersServiceSpy
)) {
// wait for execution
Flux<Execution> receive = TestsUtils.receive(executionQueue, SchedulerConditionTest.class, either -> {
Flux<Execution> receive = TestsUtils.receive(executionQueue, either -> {
Execution execution = either.getLeft();
if (execution.getState().getCurrent() == State.Type.CREATED) {
executionQueue.emit(execution.withState(State.Type.SUCCESS));

6
core/src/test/java/io/kestra/core/schedulers/SchedulerPollingTriggerTest.java
View File

@@ -1,6 +1,7 @@
package io.kestra.core.schedulers;
import io.kestra.core.utils.TestsUtils;
import io.kestra.jdbc.runner.JdbcScheduler;
import io.kestra.plugin.core.condition.ExpressionCondition;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.flows.Flow;
@@ -185,10 +186,9 @@ public class SchedulerPollingTriggerTest extends AbstractSchedulerTest {
}
private AbstractScheduler scheduler(FlowListeners flowListenersServiceSpy) {
return new DefaultScheduler(
return new JdbcScheduler(
applicationContext,
flowListenersServiceSpy,
triggerState
flowListenersServiceSpy
);
}
}

6
core/src/test/java/io/kestra/core/schedulers/SchedulerScheduleTest.java
View File

@@ -1,6 +1,7 @@
package io.kestra.core.schedulers;
import io.kestra.core.utils.TestsUtils;
import io.kestra.jdbc.runner.JdbcScheduler;
import io.kestra.plugin.core.condition.ExpressionCondition;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.executions.LogEntry;
@@ -65,10 +66,9 @@ public class SchedulerScheduleTest extends AbstractSchedulerTest {
}
protected AbstractScheduler scheduler(FlowListeners flowListenersServiceSpy) {
return new DefaultScheduler(
return new JdbcScheduler(
applicationContext,
flowListenersServiceSpy,
triggerState
flowListenersServiceSpy
);
}

8
core/src/test/java/io/kestra/core/schedulers/SchedulerStreamingTest.java
View File

@@ -13,6 +13,7 @@ import io.kestra.core.runners.Worker;
import io.kestra.core.models.triggers.TriggerService;
import io.kestra.core.utils.IdUtils;
import io.kestra.core.utils.TestsUtils;
import io.kestra.jdbc.runner.JdbcScheduler;
import jakarta.inject.Inject;
import lombok.*;
import lombok.experimental.SuperBuilder;
@@ -55,7 +56,7 @@ public class SchedulerStreamingTest extends AbstractSchedulerTest {
private void run(Flow flow, CountDownLatch queueCount, Consumer<List<Execution>> consumer) throws Exception {
// wait for execution
Flux<Execution> receive = TestsUtils.receive(executionQueue, SchedulerStreamingTest.class, either -> {
Flux<Execution> receive = TestsUtils.receive(executionQueue, either -> {
queueCount.countDown();
});
@@ -68,10 +69,9 @@ public class SchedulerStreamingTest extends AbstractSchedulerTest {
// scheduler
try (
AbstractScheduler scheduler = new DefaultScheduler(
AbstractScheduler scheduler = new JdbcScheduler(
applicationContext,
flowListenersServiceSpy,
triggerState
flowListenersServiceSpy
);
Worker worker = applicationContext.createBean(TestMethodScopedWorker.class, IdUtils.create(), 8, null)
) {

27
core/src/test/java/io/kestra/core/schedulers/SchedulerThreadTest.java
View File

@@ -11,6 +11,7 @@ import io.kestra.core.runners.TestMethodScopedWorker;
import io.kestra.core.runners.Worker;
import io.kestra.core.utils.IdUtils;
import io.kestra.core.utils.TestsUtils;
import io.kestra.jdbc.runner.JdbcScheduler;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
@@ -33,32 +34,13 @@ public class SchedulerThreadTest extends AbstractSchedulerTest {
@Inject
protected SchedulerTriggerStateInterface triggerState;
public static Flow createThreadFlow() {
return createThreadFlow(null);
}
public static Flow createThreadFlow(String workerGroup) {
UnitTest schedule = UnitTest.builder()
.id("sleep")
.type(UnitTest.class.getName())
.workerGroup(workerGroup == null ? null : new WorkerGroup(workerGroup))
.build();
return createFlow(Collections.singletonList(schedule), List.of(
PluginDefault.builder()
.type(UnitTest.class.getName())
.values(Map.of("defaultInjected", "done"))
.build()
));
}
@Test
void thread() throws Exception {
Flow flow = createThreadFlow();
CountDownLatch queueCount = new CountDownLatch(2);
// wait for execution
Flux<Execution> receive = TestsUtils.receive(executionQueue, SchedulerThreadTest.class, either -> {
Flux<Execution> receive = TestsUtils.receive(executionQueue, either -> {
Execution execution = either.getLeft();
assertThat(execution.getFlowId(), is(flow.getId()));
@@ -79,10 +61,9 @@ public class SchedulerThreadTest extends AbstractSchedulerTest {
// scheduler
try (
AbstractScheduler scheduler = new DefaultScheduler(
AbstractScheduler scheduler = new JdbcScheduler(
applicationContext,
flowListenersServiceSpy,
triggerState
flowListenersServiceSpy
);
Worker worker = applicationContext.createBean(TestMethodScopedWorker.class, IdUtils.create(), 8, null)
) {

10
core/src/test/java/io/kestra/core/schedulers/SchedulerTriggerChangeTest.java
View File

@@ -13,6 +13,7 @@ import io.kestra.core.models.triggers.TriggerService;
import io.kestra.core.queues.QueueFactoryInterface;
import io.kestra.core.queues.QueueInterface;
import io.kestra.core.runners.*;
import io.kestra.jdbc.runner.JdbcScheduler;
import io.kestra.plugin.core.debug.Return;
import io.kestra.core.utils.Await;
import io.kestra.core.utils.IdUtils;
@@ -79,12 +80,12 @@ public class SchedulerTriggerChangeTest extends AbstractSchedulerTest {
CountDownLatch executionKilledCount = new CountDownLatch(1);
// wait for execution
Flux<Execution> receiveExecutions = TestsUtils.receive(executionQueue, SchedulerThreadTest.class, either -> {
Flux<Execution> receiveExecutions = TestsUtils.receive(executionQueue, either -> {
executionQueueCount.countDown();
});
// wait for killed
Flux<ExecutionKilled> receiveKilled = TestsUtils.receive(killedQueue, SchedulerThreadTest.class, either -> {
Flux<ExecutionKilled> receiveKilled = TestsUtils.receive(killedQueue, either -> {
executionKilledCount.countDown();
});
@@ -94,10 +95,9 @@ public class SchedulerTriggerChangeTest extends AbstractSchedulerTest {
// scheduler
try (
AbstractScheduler scheduler = new DefaultScheduler(
AbstractScheduler scheduler = new JdbcScheduler(
applicationContext,
flowListenersService,
triggerState
flowListenersService
);
Worker worker = applicationContext.createBean(TestMethodScopedWorker.class, IdUtils.create(), 8, null)
) {

4
core/src/test/java/io/kestra/core/schedulers/SchedulerTriggerStateInterfaceTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.schedulers;
import io.kestra.core.models.triggers.Trigger;
import io.kestra.core.utils.IdUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -12,7 +12,7 @@ import java.util.Optional;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
public abstract class SchedulerTriggerStateInterfaceTest {
@Inject
protected SchedulerTriggerStateInterface triggerState;

4
core/src/test/java/io/kestra/core/secret/SecretFunctionTest.java
View File

@@ -8,7 +8,7 @@ import io.kestra.core.queues.QueueInterface;
import io.kestra.core.runners.AbstractMemoryRunnerTest;
import io.kestra.core.runners.RunnerUtils;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.junit.jupiter.api.Test;
@@ -23,7 +23,7 @@ import java.util.concurrent.TimeoutException;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
public class SecretFunctionTest extends AbstractMemoryRunnerTest {
@Inject
@Named(QueueFactoryInterface.WORKERTASKLOG_NAMED)

4
core/src/test/java/io/kestra/core/serializers/ObjectMapperFactoryTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.serializers;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.jupiter.api.Test;
@@ -15,7 +15,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class ObjectMapperFactoryTest {
@Inject
ObjectMapper objectMapper;

4
core/src/test/java/io/kestra/core/serializers/YamlFlowParserTest.java
View File

@@ -10,7 +10,7 @@ import io.kestra.core.models.tasks.Task;
import io.kestra.core.models.tasks.retrys.Constant;
import io.kestra.core.models.validations.ModelValidator;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -30,7 +30,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class YamlFlowParserTest {
private static ObjectMapper mapper = JacksonMapper.ofJson();

4
core/src/test/java/io/kestra/core/server/ServerConfigTest.java
View File

@@ -1,13 +1,13 @@
package io.kestra.core.server;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import java.time.Duration;
@MicronautTest
@KestraTest
class ServerConfigTest {
@Inject

12
core/src/test/java/io/kestra/core/services/CollectorServiceTest.java
View File

@@ -7,8 +7,9 @@ import io.kestra.core.models.Setting;
import io.kestra.core.models.collectors.Usage;
import io.kestra.core.repositories.SettingRepositoryInterface;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.annotation.Primary;
import io.micronaut.context.annotation.Requires;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Singleton;
import org.junit.jupiter.api.Test;
@@ -22,7 +23,7 @@ import jakarta.validation.ConstraintViolationException;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class CollectorServiceTest {
@Test
public void metrics() throws URISyntaxException {
@@ -46,14 +47,17 @@ class CollectorServiceTest {
assertThat(metrics.getConfigurations().getRepositoryType(), is("memory"));
assertThat(metrics.getConfigurations().getQueueType(), is("memory"));
assertThat(metrics.getExecutions(), notNullValue());
assertThat(metrics.getExecutions().getDailyExecutionsCount().size(), is(0));
assertThat(metrics.getExecutions().getDailyTaskRunsCount().size(), is(0));
// 1 per hour
assertThat(metrics.getExecutions().getDailyExecutionsCount().size(), greaterThan(0));
// no task runs as it's an empty instance
assertThat(metrics.getExecutions().getDailyTaskRunsCount(), nullValue());
assertThat(metrics.getInstanceUuid(), is(TestSettingRepository.instanceUuid));
}
}
@Singleton
@Requires(property = "kestra.unittest")
@Primary
public static class TestSettingRepository implements SettingRepositoryInterface {
public static Object instanceUuid = null;

4
core/src/test/java/io/kestra/core/services/ConditionServiceTest.java
View File

@@ -14,7 +14,7 @@ import io.kestra.core.queues.QueueFactoryInterface;
import io.kestra.core.queues.QueueInterface;
import io.kestra.core.runners.RunContextFactory;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.junit.jupiter.api.Test;
@@ -29,7 +29,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
@MicronautTest
@KestraTest
class ConditionServiceTest {
@Inject
ConditionService conditionService;

4
core/src/test/java/io/kestra/core/services/FlowServiceTest.java
View File

@@ -7,7 +7,7 @@ import io.kestra.core.models.flows.input.StringInput;
import io.kestra.core.repositories.FlowRepositoryInterface;
import io.kestra.plugin.core.debug.Echo;
import io.kestra.plugin.core.debug.Return;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -22,7 +22,7 @@ import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertTrue;
@MicronautTest
@KestraTest
class FlowServiceTest {
@Inject
private FlowService flowService;

4
core/src/test/java/io/kestra/core/services/FlowTopologyServiceTest.java
View File

@@ -13,7 +13,7 @@ import io.kestra.plugin.core.flow.Parallel;
import io.kestra.plugin.core.flow.Subflow;
import io.kestra.core.topologies.FlowTopologyService;
import io.kestra.core.utils.TestsUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -26,7 +26,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
@MicronautTest
@KestraTest
class FlowTopologyServiceTest {
@Inject
private FlowTopologyService flowTopologyService;

4
core/src/test/java/io/kestra/core/services/LogServiceTest.java
View File

@@ -4,13 +4,13 @@ import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.executions.TaskRun;
import io.kestra.core.models.flows.Flow;
import io.kestra.core.models.triggers.TriggerContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.slf4j.event.Level;
@MicronautTest
@KestraTest
@Slf4j
class LogServiceTest {
@Inject

4
core/src/test/java/io/kestra/core/services/PluginDefaultServiceTest.java
View File

@@ -16,7 +16,7 @@ import io.kestra.core.models.triggers.TriggerContext;
import io.kestra.core.models.triggers.TriggerOutput;
import io.kestra.plugin.core.trigger.Schedule;
import io.kestra.core.runners.RunContext;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
@@ -35,7 +35,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class PluginDefaultServiceTest {
@Inject
private PluginDefaultService pluginDefaultService;

4
core/src/test/java/io/kestra/core/services/SkipExecutionServiceTest.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.services;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.executions.TaskRun;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -11,7 +11,7 @@ import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
@MicronautTest
@KestraTest
class SkipExecutionServiceTest {
@Inject
private SkipExecutionService skipExecutionService;

4
core/src/test/java/io/kestra/core/services/StartExecutorServiceTest.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.services;
import io.micronaut.context.annotation.Property;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -10,7 +10,7 @@ import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
@MicronautTest
@KestraTest
@Property(name = "kestra.queue.type", value = "kafka")
class StartExecutorServiceTest {
@Inject

4
core/src/test/java/io/kestra/core/services/TaskGlobalDefaultConfiguration.java
View File

@@ -2,7 +2,7 @@ package io.kestra.core.services;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.env.Environment;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.util.List;
@@ -12,7 +12,7 @@ import java.util.Set;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
@KestraTest
class TaskGlobalDefaultConfigurationTest {
@SuppressWarnings("unchecked")
@Test

4
core/src/test/java/io/kestra/core/storage/StorageTestSuite.java
View File

@@ -4,7 +4,7 @@ import com.google.common.io.CharStreams;
import io.kestra.core.storages.FileAttributes;
import io.kestra.core.storages.StorageInterface;
import io.kestra.core.utils.IdUtils;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -19,7 +19,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.jupiter.api.Assertions.*;
@MicronautTest
@KestraTest
public abstract class StorageTestSuite {
private static final String contentString = "Content";

4
core/src/test/java/io/kestra/core/storages/StorageInterfaceFactoryTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.storages;
import io.kestra.core.exceptions.KestraRuntimeException;
import io.kestra.core.plugins.DefaultPluginRegistry;
import io.kestra.storage.local.LocalStorage;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
@@ -13,7 +13,7 @@ import org.junit.jupiter.api.Test;
import java.util.Map;
@MicronautTest
@KestraTest
class StorageInterfaceFactoryTest {
DefaultPluginRegistry registry = DefaultPluginRegistry.getOrCreate();

5
core/src/test/java/io/kestra/core/tasks/PluginUtilsServiceTest.java
View File

@@ -3,7 +3,7 @@ package io.kestra.core.tasks;
import io.kestra.core.exceptions.IllegalVariableEvaluationException;
import io.kestra.core.models.tasks.runners.PluginUtilsService;
import io.kestra.core.runners.RunContextFactory;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
@@ -19,9 +19,8 @@ import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.startsWith;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
public class PluginUtilsServiceTest {
@Inject
private RunContextFactory runContextFactory;

4
core/src/test/java/io/kestra/core/tenant/TenantServiceTest.java
View File

@@ -1,13 +1,13 @@
package io.kestra.core.tenant;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.nullValue;
@MicronautTest
@KestraTest
class TenantServiceTest {
@Inject
private TenantService tenantService;

4
core/src/test/java/io/kestra/core/utils/RetryUtilsTest.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.utils;
import io.kestra.core.models.tasks.retrys.Constant;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -14,7 +14,7 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.junit.jupiter.api.Assertions.assertThrows;
@MicronautTest
@KestraTest
class RetryUtilsTest {
@Inject
RetryUtils retryUtils;

52
core/src/test/java/io/kestra/core/utils/TestUtilsTest.java
View File

@@ -1,52 +0,0 @@
package io.kestra.core.utils;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.queues.QueueFactoryInterface;
import io.kestra.core.queues.QueueInterface;
import io.kestra.runner.memory.MemoryQueue;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
import java.time.Duration;
import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
@MicronautTest
public class TestUtilsTest {
@Inject
@Named(QueueFactoryInterface.EXECUTION_NAMED)
private QueueInterface<Execution> executionMemoryQueue;
@Test
void receive() throws InterruptedException {
MemoryQueue<Execution> cast = (MemoryQueue<Execution>) executionMemoryQueue;
int subscribersCount = cast.getSubscribersCount();
Flux<Execution> receive = TestsUtils.receive(executionMemoryQueue);
assertThat(cast.getSubscribersCount(), is(subscribersCount + 1));
receive.blockLast();
assertThat(cast.getSubscribersCount(), is(subscribersCount));
receive = TestsUtils.receive(executionMemoryQueue, either -> {
if (either.getLeft().getId().equals("1")) {
executionMemoryQueue.emit(Execution.builder().id("2").build());
}
});
executionMemoryQueue.emit(Execution.builder().id("1").build());
Thread.sleep(10000);
assertThat(cast.getSubscribersCount(), is(subscribersCount + 1));
List<Execution> executions = receive.collectList().block();
assertThat(cast.getSubscribersCount(), is(subscribersCount));
//assertThat(executions, is(List.of(Execution.builder().id("1").build(), Execution.builder().id("2").build())));
assertThat(cast.getSubscribersCount(), is(subscribersCount));
TestsUtils.receive(executionMemoryQueue, null, null, null, Duration.ofSeconds(5));
assertThat(cast.getSubscribersCount(), is(subscribersCount + 1));
Thread.sleep(10000);
assertThat(cast.getSubscribersCount(), is(subscribersCount));
}
}

0
core/src/main/java/io/kestra/core/utils/TestsUtils.java → core/src/test/java/io/kestra/core/utils/TestsUtils.java
View File

4
core/src/test/java/io/kestra/core/utils/UriProviderTest.java
View File

@@ -1,7 +1,7 @@
package io.kestra.core.utils;
import com.google.common.collect.ImmutableMap;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.kestra.core.junit.annotations.KestraTest;
import org.junit.jupiter.api.Test;
import io.kestra.core.models.executions.Execution;
import io.kestra.core.models.flows.Flow;
@@ -11,7 +11,7 @@ import jakarta.inject.Inject;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
@MicronautTest
@KestraTest
class UriProviderTest {
@Inject
UriProvider uriProvider;

Some files were not shown because too many files have changed in this diff Show More