added transaction behavior test

Author: sterlp

core/src/main/java/org/sterl/spring/persistent_tasks/api/PersistentTask.java

@@ -3,9 +3,12 @@
 import java.io.Serializable;
 
 /**
- * A spring persistentTask which state is saved in a {@link Trigger}.
- * 
- * @param <T> the state type
+ * A Spring persistent task whose state is saved in a {@link Trigger}.
+ *
+ * <p>This interface defines a task that accepts a state of type <code>T</code> and
+ * provides default implementations for retry strategies.
+ *
+ * @param <T> the type of the state, which must be {@link Serializable}
  */
 @FunctionalInterface
 public interface PersistentTask<T extends Serializable> {

core/src/main/java/org/sterl/spring/persistent_tasks/api/TransactionalTask.java

@@ -0,0 +1,30 @@
+package org.sterl.spring.persistent_tasks.api;
+
+import java.io.Serializable;
+
+/**
+ * Similar to {@link PersistentTask} but specifically for transactional workloads.
+ * Use this interface when the task execution should be wrapped in a transaction.
+ *
+ * <p>This interface ensures that the task's execution is transactional, meaning that it will
+ * be executed within a transaction context, along with the state update and the dispatching of
+ * relevant events.
+ *
+ * @param <T> the type of the state, which must be {@link Serializable}
+ */
+@FunctionalInterface
+public interface TransactionalTask<T extends Serializable> extends PersistentTask<T> {
+    /**
+     * Whether the persistentTask is transaction or not. If <code>true</code> the execution
+     * is wrapped into the default transaction template together with the state update
+     * and the following events:
+     * <ol>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerRunningEvent</li>
+     * <li>org.sterl.spring.persistent_tasks.trigger.event.TriggerSuccessEvent</li>
+     * </ol>
+     * @return {@code true} if the persistentTask is transactional; {@code false} otherwise.
+     */
+    default boolean isTransactional() {
+        return true;
+    }
+}

core/src/main/java/org/sterl/spring/persistent_tasks/task/TaskService.java

@@ -27,7 +27,6 @@ public Set<TaskId<? extends Serializable>> findAllTaskIds() {
         return this.taskRepository.all();
     }
 
-
     public <T extends Serializable> Optional<PersistentTask<T>> get(TaskId<T> id) {
         return taskRepository.get(id);
     }

core/src/main/java/org/sterl/spring/persistent_tasks/task/util/ReflectionUtil.java

@@ -0,0 +1,24 @@
+package org.sterl.spring.persistent_tasks.task.util;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+
+import org.springframework.aop.framework.AopProxyUtils;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.util.ReflectionUtils;
+import org.sterl.spring.persistent_tasks.api.PersistentTask;
+
+public abstract class ReflectionUtil {
+
+    public static <A extends Annotation> A getAnnotation(PersistentTask<? extends Serializable> inTask, Class<A> searchFor) {
+        var task = AopProxyUtils.ultimateTargetClass(inTask);
+        A result = AnnotationUtils.findAnnotation(task, searchFor);
+        if (result != null) return result;
+
+        var targetMethod = ReflectionUtils.findMethod(task, "accept", Serializable.class);
+        if (targetMethod == null) return null;
+
+        result = AnnotationUtils.findAnnotation(targetMethod, searchFor);
+        return result;
+    }
+}

core/src/test/java/org/sterl/spring/persistent_tasks/AbstractSpringTest.java

@@ -163,14 +163,14 @@ protected Optional<TriggerEntity> runNextTrigger() {
 
     @BeforeEach
     public void beforeEach() throws Exception {
-        hibernateAsserts.reset();
         triggerService.deleteAll();
         historyService.deleteAll();
         asserts.clear();
         schedulerA.setMaxThreads(10);
         schedulerB.setMaxThreads(20);
         schedulerA.start();
         schedulerB.start();
+        hibernateAsserts.reset();
     }
 
     @AfterEach

core/src/test/java/org/sterl/spring/persistent_tasks/task/TaskTransactionTest.java

@@ -0,0 +1,129 @@
+package org.sterl.spring.persistent_tasks.task;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.DefaultTransactionDefinition;
+import org.sterl.spring.persistent_tasks.AbstractSpringTest;
+import org.sterl.spring.persistent_tasks.api.PersistentTask;
+import org.sterl.spring.persistent_tasks.api.TaskId.TaskTriggerBuilder;
+import org.sterl.spring.persistent_tasks.api.TransactionalTask;
+import org.sterl.spring.persistent_tasks.task.util.ReflectionUtil;
+import org.sterl.spring.sample_app.person.PersonBE;
+import org.sterl.spring.sample_app.person.PersonRepository;
+
+import lombok.RequiredArgsConstructor;
+
+class TaskTransactionTest extends AbstractSpringTest {
+
+    @Component("transactionalClass")
+    @Transactional(timeout = 5, propagation = Propagation.MANDATORY)
+    @RequiredArgsConstructor
+    static class TransactionalClass implements PersistentTask<String> {
+        private final PersonRepository personRepository;
+        @Override
+        public void accept(String name) {
+            personRepository.save(new PersonBE(name));
+        }
+    }
+    @Component("transactionalMethod")
+    @RequiredArgsConstructor
+    static class TransactionalMethod implements PersistentTask<String> {
+        private final PersonRepository personRepository;
+        @Transactional(timeout = 6, propagation = Propagation.MANDATORY)
+        @Override
+        public void accept(String name) {
+            personRepository.save(new PersonBE(name));
+        }
+    }
+
+    /**
+     * A closure cannot be annotated, so we use a anonymous class
+     */
+    @Configuration
+    static class Config {
+        @Bean("transactionalAnonymous")
+        PersistentTask<String> transactionalAnonymous(PersonRepository personRepository) {
+            return new PersistentTask<String>() {
+                @Transactional(timeout = 7, propagation = Propagation.MANDATORY)
+                @Override
+                public void accept(String name) {
+                    personRepository.save(new PersonBE(name));
+                } 
+            };
+        }
+        @Bean("transactionalClosure")
+        TransactionalTask<String> transactionalClosure(PersonRepository personRepository) {
+            return name -> {
+                personRepository.save(new PersonBE(name));
+                personRepository.save(new PersonBE(name));
+            };
+        }
+    }
+    
+    @Autowired PersonRepository personRepository;
+
+    @Autowired @Qualifier("transactionalClass")
+    PersistentTask<String> transactionalClass;
+    @Autowired @Qualifier("transactionalMethod")
+    PersistentTask<String> transactionalMethod;
+    @Autowired @Qualifier("transactionalAnonymous")
+    PersistentTask<String> transactionalAnonymous;
+
+    @Test
+    void testFindTransactionAnnotation() {
+        var a = ReflectionUtil.getAnnotation(transactionalClass, Transactional.class);
+        assertThat(a).isNotNull();
+        assertThat(a.timeout()).isEqualTo(5);
+        
+        a = ReflectionUtil.getAnnotation(transactionalMethod, Transactional.class);
+        assertThat(a).isNotNull();
+        assertThat(a.timeout()).isEqualTo(6);
+        
+        a = ReflectionUtil.getAnnotation(transactionalAnonymous, Transactional.class);
+        assertThat(a).isNotNull();
+        assertThat(a.timeout()).isEqualTo(7);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"transactionalClass", "transactionalMethod", "transactionalClosure"})
+    void testTransactionalTask(String task) {
+        // GIVEN
+        var t = triggerService.queue(TaskTriggerBuilder
+                .newTrigger(task, "test").build());
+        
+        // WHEN
+        personRepository.deleteAllInBatch();
+        hibernateAsserts.reset();
+        triggerService.run(t).get();
+        
+        // THEN
+        hibernateAsserts.assertTrxCount(1);
+        assertThat(personRepository.count()).isEqualTo(2);
+    }
+
+    public static DefaultTransactionDefinition convertTransactionalToDefinition(Transactional transactional) {
+        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
+
+        // Map Transactional attributes to DefaultTransactionDefinition
+        def.setIsolationLevel(transactional.isolation().value());
+        def.setPropagationBehavior(transactional.propagation().value());
+        def.setTimeout(transactional.timeout());
+        def.setReadOnly(transactional.readOnly());
+        // No direct mapping for 'rollbackFor' or 'noRollbackFor'
+        // Set a name if desired (e.g., based on transactional class/method)
+        def.setName("TransactionalDefinition");
+
+        return def;
+    }
+
+}

core/src/test/java/org/sterl/spring/persistent_tasks/task/TransactionAnnotationTest.java

@@ -57,6 +57,10 @@ void testAddTrigger() throws Exception {
         final var triggerId = subject.queue(trigger).getKey();
 
         // THEN
+        hibernateAsserts.assertTrxCount(1);
+        // one for the trigger and two for the history
+        hibernateAsserts.assertInsertCount(3);
+        // AND
         final var e = subject.get(triggerId);
         assertThat(e).isPresent();
         assertThat(e.get().getData().getRunAt().toEpochSecond()).isEqualTo(triggerTime.toEpochSecond());