added test for REQUIRES_NEW

Author: sterlp

RUN_AND_BUILD.md

@@ -1,5 +1,5 @@
 mvn versions:display-dependency-updates
-mvn versions:set -DnewVersion=1.3.1 -DgenerateBackupPoms=false
+mvn versions:set -DnewVersion=1.4.0-SNAPSHOT -DgenerateBackupPoms=false
 mvn versions:set -DnewVersion=1.3.2-SNAPSHOT -DgenerateBackupPoms=false
 
 ## postgres

core/src/test/java/org/sterl/spring/persistent_tasks/scheduler/SchedulerServiceTransactionTest.java

@@ -10,10 +10,10 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.transaction.annotation.Transactional;
 import org.sterl.spring.persistent_tasks.AbstractSpringTest;
-import org.sterl.spring.persistent_tasks.api.RetryStrategy;
 import org.sterl.spring.persistent_tasks.api.PersistentTask;
+import org.sterl.spring.persistent_tasks.api.RetryStrategy;
+import org.sterl.spring.persistent_tasks.api.TransactionalTask;
 import org.sterl.spring.persistent_tasks.api.TaskId.TaskTriggerBuilder;
 import org.sterl.spring.persistent_tasks.api.TriggerKey;
 import org.sterl.spring.persistent_tasks.shared.model.TriggerStatus;
@@ -24,15 +24,13 @@ class SchedulerServiceTransactionTest extends AbstractSpringTest {
 
     private SchedulerService subject;
     private static AtomicBoolean sendError = new AtomicBoolean(false);
-    private static AtomicBoolean inTrx = new AtomicBoolean(false);
     @Autowired private PersonRepository personRepository;
 
     @Configuration
     static class Config {
         @Bean
-        PersistentTask<String> savePerson(PersonRepository personRepository) {
-            return new PersistentTask<>() {
-                @Transactional
+        PersistentTask<String> savePersonInTrx(PersonRepository personRepository) {
+            return new TransactionalTask<String>() {
                 @Override
                 public void accept(String name) {
                     personRepository.save(new PersonBE(name));
@@ -43,9 +41,21 @@ public void accept(String name) {
                 public RetryStrategy retryStrategy() {
                     return RetryStrategy.THREE_RETRIES_IMMEDIATELY;
                 }
+            };
+        }
+        
+        @Bean
+        PersistentTask<String> savePersonNoTrx(PersonRepository personRepository) {
+            return new PersistentTask<>() {
                 @Override
-                public boolean isTransactional() {
-                    return inTrx.get();
+                public void accept(String name) {
+                    personRepository.save(new PersonBE(name));
+                    if (sendError.get()) {
+                        throw new RuntimeException("Error requested for " + name);
+                    }
+                }
+                public RetryStrategy retryStrategy() {
+                    return RetryStrategy.THREE_RETRIES_IMMEDIATELY;
                 }
             };
         }
@@ -57,64 +67,63 @@ public void beforeEach() throws Exception {
         subject = schedulerService;
         personRepository.deleteAllInBatch();
         sendError.set(false);
-        inTrx.set(false);
     }
-    
+
     @Test
-    void testSaveEntity() throws Exception {
+    void testSaveTransactions() throws Exception {
         // GIVEN
-        final var trigger = TaskTriggerBuilder.newTrigger("savePerson").state("Paul").build();
+        final var request = TaskTriggerBuilder.newTrigger("savePersonNoTrx").state("Paul").build();
+        var trigger = triggerService.queue(request);
 
         // WHEN
         hibernateAsserts.reset();
-        subject.runOrQueue(trigger).get();
+        triggerService.run(trigger);
 
         // THEN
-        // AND one the service, one the event and one more status update, 
-        // one more to save the trigger
-        hibernateAsserts.assertTrxCount(4);
+        // AND one the service, one the event and one more status update
+        hibernateAsserts.assertTrxCount(3);
         assertThat(personRepository.count()).isOne();
     }
 
+    
     @Test
-    void testSaveTransactions() throws Exception {
+    void testTrxCountTriggerService() throws Exception {
         // GIVEN
-        final var request = TaskTriggerBuilder.newTrigger("savePerson").state("Paul").build();
+        final var request = TaskTriggerBuilder.newTrigger("savePersonInTrx").state("Paul").build();
         var trigger = triggerService.queue(request);
 
         // WHEN
         hibernateAsserts.reset();
         triggerService.run(trigger);
 
         // THEN
-        // AND one the service, one the event and one more status update
-        hibernateAsserts.assertTrxCount(3);
+        hibernateAsserts.assertTrxCount(1);
         assertThat(personRepository.count()).isOne();
     }
-
 
     @Test
-    void testTrxCountTriggerService() throws Exception {
+    void testFailTrxCount() throws Exception {
         // GIVEN
-        final var request = TaskTriggerBuilder.newTrigger("savePerson").state("Paul").build();
+        final var request = TaskTriggerBuilder.newTrigger("savePersonInTrx").state("Paul").build();
         var trigger = triggerService.queue(request);
-        inTrx.set(true);
+        sendError.set(true);
 
         // WHEN
         hibernateAsserts.reset();
         triggerService.run(trigger);
 
         // THEN
-        hibernateAsserts.assertTrxCount(1);
-        assertThat(personRepository.count()).isOne();
+        // first the work which runs on error
+        // second the update to the trigger
+        // third to write the history
+        hibernateAsserts.assertTrxCount(3);
     }
 
     @Test
     void testRollbackAndRetry() throws Exception {
         // GIVEN
-        final var triggerRequest = TaskTriggerBuilder.newTrigger("savePerson").state("Paul").build();
+        final var triggerRequest = TaskTriggerBuilder.newTrigger("savePersonInTrx").state("Paul").build();
         sendError.set(true);
-        inTrx.set(true);
 
         // WHEN
         var key = subject.runOrQueue(triggerRequest);

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

@@ -56,7 +56,7 @@ static class Config {
         @Bean("transactionalAnonymous")
         PersistentTask<String> transactionalAnonymous(PersonRepository personRepository) {
             return new PersistentTask<String>() {
-                @Transactional(timeout = 7, propagation = Propagation.MANDATORY)
+                @Transactional(timeout = 7, propagation = Propagation.REQUIRES_NEW)
                 @Override
                 public void accept(String name) {
                     personRepository.save(new PersonBE(name));
@@ -111,9 +111,23 @@ void testGetTransactionTemplate() {
         assertThat(a.get().getIsolationLevel()).isEqualTo(Isolation.REPEATABLE_READ.value());
 
         a = subject.getTransactionTemplate(transactionalAnonymous);
-        assertThat(a).isPresent();
-        assertThat(a.get().getTimeout()).isEqualTo(7);
-        assertThat(a.get().getPropagationBehavior()).isEqualTo(Propagation.REQUIRED.value());
+        assertThat(a).isEmpty();
+    }
+    
+    @Test
+    void testRequiresNewHasOwnTransaction() {
+        // GIVEN
+        var t = triggerService.queue(TaskTriggerBuilder
+                .newTrigger("transactionalAnonymous", "test").build());
+        
+        // WHEN
+        personRepository.deleteAllInBatch();
+        hibernateAsserts.reset();
+        triggerService.run(t).get();
+        
+        // THEN
+        hibernateAsserts.assertTrxCount(3);
+        assertThat(personRepository.count()).isEqualTo(1);
     }
 
     @ParameterizedTest