Closes #2463: Refactor WorkbasketCleanupJobAccTest to use Test-API

lib/taskana-core-test/src/test/java/acceptance/jobs/AbstractTaskanaJobAccTest.java

@@ -31,6 +31,7 @@ import pro.taskana.testapi.TaskanaConfigurationModifier;
 import pro.taskana.testapi.TaskanaInject;
 import pro.taskana.testapi.TaskanaIntegrationTest;
 import pro.taskana.testapi.security.WithAccessId;
+import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
 
 @TaskanaIntegrationTest
 class AbstractTaskanaJobAccTest {
@@ -49,6 +50,7 @@ class AbstractTaskanaJobAccTest {
     jobMapper.deleteMultiple(TaskCleanupJob.class.getName());
     jobMapper.deleteMultiple(TaskRefreshJob.class.getName());
     jobMapper.deleteMultiple(ClassificationChangedJob.class.getName());
+    jobMapper.deleteMultiple(WorkbasketCleanupJob.class.getName());
   }
 
   @WithAccessId(user = "admin")
@@ -105,30 +107,34 @@ class AbstractTaskanaJobAccTest {
     assertThat(jobsToRun).doesNotContainAnyElementsOf(taskCleanupJobs);
   }
 
-  @Nested
+  @WithAccessId(user = "admin")
-  @TestInstance(Lifecycle.PER_CLASS)
+  @Test
-  class CleanCompletedTasks implements TaskanaConfigurationModifier {
+  void should_DeleteOldWorkbasketCleanupJobs_When_InitializingSchedule() throws Exception {
-    @TaskanaInject TaskanaEngine taskanaEngine;
 
-    @TaskanaInject JobMapper jobMapper;
+    for (int i = 0; i < 10; i++) {
-
+      ScheduledJob job = new ScheduledJob();
-    @Override
+      job.setType(WorkbasketCleanupJob.class.getName());
-    public Builder modify(Builder builder) {
+      taskanaEngine.getJobService().createJob(job);
-      return builder
+      job.setType(TaskRefreshJob.class.getName());
-          .taskCleanupJobEnabled(true)
+      taskanaEngine.getJobService().createJob(job);
-          .jobRunEvery(Duration.ofMillis(1))
+      job.setType(ClassificationChangedJob.class.getName());
-          .jobFirstRun(Instant.now().plus(5, ChronoUnit.MINUTES));
+      taskanaEngine.getJobService().createJob(job);
     }
+    List<ScheduledJob> jobsToRun = jobMapper.findJobsToRun(Instant.now());
 
-    @WithAccessId(user = "admin")
+    assertThat(jobsToRun).hasSize(30);
-    @Test
-    void should_FindNoJobsToRunUntilFirstRunIsReached_When_CleanupScheduleIsInitialized()
-        throws Exception {
-      AbstractTaskanaJob.initializeSchedule(taskanaEngine, TaskCleanupJob.class);
 
-      List<ScheduledJob> nextJobs = jobMapper.findJobsToRun(Instant.now());
+    List<ScheduledJob> workbasketCleanupJobs =
-      assertThat(nextJobs).isEmpty();
+        jobsToRun.stream()
-    }
+            .filter(
+                scheduledJob -> scheduledJob.getType().equals(WorkbasketCleanupJob.class.getName()))
+            .toList();
+
+    AbstractTaskanaJob.initializeSchedule(taskanaEngine, WorkbasketCleanupJob.class);
+
+    jobsToRun = jobMapper.findJobsToRun(Instant.now());
+
+    assertThat(jobsToRun).doesNotContainAnyElementsOf(workbasketCleanupJobs);
   }
 
   @Test
@@ -172,4 +178,30 @@ class AbstractTaskanaJobAccTest {
     @Override
     protected void execute() throws TaskanaException {}
   }
+
+  @Nested
+  @TestInstance(Lifecycle.PER_CLASS)
+  class CleanCompletedTasks implements TaskanaConfigurationModifier {
+    @TaskanaInject TaskanaEngine taskanaEngine;
+
+    @TaskanaInject JobMapper jobMapper;
+
+    @Override
+    public Builder modify(Builder builder) {
+      return builder
+          .taskCleanupJobEnabled(true)
+          .jobRunEvery(Duration.ofMillis(1))
+          .jobFirstRun(Instant.now().plus(5, ChronoUnit.MINUTES));
+    }
+
+    @WithAccessId(user = "admin")
+    @Test
+    void should_FindNoJobsToRunUntilFirstRunIsReached_When_CleanupScheduleIsInitialized()
+        throws Exception {
+      AbstractTaskanaJob.initializeSchedule(taskanaEngine, TaskCleanupJob.class);
+
+      List<ScheduledJob> nextJobs = jobMapper.findJobsToRun(Instant.now());
+      assertThat(nextJobs).isEmpty();
+    }
+  }
 }

lib/taskana-core-test/src/test/java/acceptance/jobs/WorkbasketCleanupJobAccTest.java

@@ -0,0 +1,79 @@
+package acceptance.jobs;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import pro.taskana.classification.api.ClassificationService;
+import pro.taskana.classification.api.models.ClassificationSummary;
+import pro.taskana.common.api.TaskanaEngine;
+import pro.taskana.task.api.TaskService;
+import pro.taskana.task.api.TaskState;
+import pro.taskana.task.api.models.ObjectReference;
+import pro.taskana.testapi.DefaultTestEntities;
+import pro.taskana.testapi.TaskanaInject;
+import pro.taskana.testapi.TaskanaIntegrationTest;
+import pro.taskana.testapi.builder.TaskBuilder;
+import pro.taskana.testapi.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.models.Workbasket;
+import pro.taskana.workbasket.api.models.WorkbasketSummary;
+import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
+
+// All tests are executed as admin, because the jobrunner needs admin rights.
+@TaskanaIntegrationTest
+class WorkbasketCleanupJobAccTest {
+  @TaskanaInject TaskService taskService;
+  @TaskanaInject WorkbasketService workbasketService;
+  @TaskanaInject ClassificationService classificationService;
+  @TaskanaInject TaskanaEngine taskanaEngine;
+
+  ClassificationSummary classification;
+  ObjectReference primaryObjRef;
+
+  @WithAccessId(user = "businessadmin")
+  @BeforeAll
+  void setup() throws Exception {
+    classification =
+        DefaultTestEntities.defaultTestClassification()
+            .buildAndStoreAsSummary(classificationService);
+    primaryObjRef = DefaultTestEntities.defaultTestObjectReference().build();
+  }
+
+  @WithAccessId(user = "admin")
+  @Test
+  void should_CleanWorkbasketMarkedForDeletion_When_WorkbasketHasNoTasks() throws Exception {
+    WorkbasketSummary wbSummary =
+        DefaultTestEntities.defaultTestWorkbasket()
+            .markedForDeletion(true)
+            .buildAndStore(workbasketService);
+
+    WorkbasketCleanupJob job = new WorkbasketCleanupJob(taskanaEngine, null, null);
+    job.run();
+
+    List<WorkbasketSummary> wbSummaries =
+        workbasketService.createWorkbasketQuery().idIn(wbSummary.getId()).list();
+    assertThat(wbSummaries).isEmpty();
+  }
+
+  @WithAccessId(user = "admin")
+  @Test
+  void should_NotCleanWorkbasketMarkedForDeletion_When_WorkbasketHasTasks() throws Exception {
+    Workbasket wb = DefaultTestEntities.defaultTestWorkbasket().buildAndStore(workbasketService);
+    TaskBuilder.newTask()
+        .workbasketSummary(wb.asSummary())
+        .classificationSummary(classification)
+        .primaryObjRef(primaryObjRef)
+        .state(TaskState.COMPLETED)
+        .buildAndStore(taskService);
+
+    // Workbasket with completed task will be marked for deletion.
+    workbasketService.deleteWorkbasket(wb.getId());
+    WorkbasketCleanupJob job = new WorkbasketCleanupJob(taskanaEngine, null, null);
+    job.run();
+
+    List<WorkbasketSummary> wbSummaries = workbasketService.createWorkbasketQuery().list();
+    assertThat(wbSummaries).hasSize(1);
+  }
+}

lib/taskana-core/src/test/java/acceptance/jobs/WorkbasketCleanupJobAccTest.java

@@ -1,137 +0,0 @@
-package acceptance.jobs;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import acceptance.AbstractAccTest;
-import java.time.Instant;
-import java.util.List;
-import java.util.stream.Collectors;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import pro.taskana.classification.internal.jobs.ClassificationChangedJob;
-import pro.taskana.common.api.BaseQuery;
-import pro.taskana.common.api.ScheduledJob;
-import pro.taskana.common.internal.jobs.AbstractTaskanaJob;
-import pro.taskana.common.test.security.JaasExtension;
-import pro.taskana.common.test.security.WithAccessId;
-import pro.taskana.task.api.TaskState;
-import pro.taskana.task.internal.jobs.TaskCleanupJob;
-import pro.taskana.task.internal.jobs.TaskRefreshJob;
-import pro.taskana.workbasket.api.WorkbasketService;
-import pro.taskana.workbasket.api.models.WorkbasketSummary;
-import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
-
-/** Acceptance test for all "jobs workbasket runner" scenarios. */
-@ExtendWith(JaasExtension.class)
-class WorkbasketCleanupJobAccTest extends AbstractAccTest {
-
-  WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-  @AfterEach
-  void after() throws Exception {
-    resetDb(true);
-  }
-
-  @WithAccessId(user = "admin")
-  @Test
-  void shouldCleanWorkbasketMarkedForDeletionWithoutTasks() throws Exception {
-    long totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
-    assertThat(totalWorkbasketCount).isEqualTo(26);
-    List<WorkbasketSummary> workbaskets =
-        workbasketService
-            .createWorkbasketQuery()
-            .keyIn("TEAMLEAD-1")
-            .orderByKey(BaseQuery.SortDirection.ASCENDING)
-            .list();
-
-    assertThat(getNumberTaskNotCompleted(workbaskets.get(0).getId())).isZero();
-    assertThat(getNumberTaskCompleted(workbaskets.get(0).getId())).isOne();
-
-    // Workbasket with completed task will be marked for deletion.
-    workbasketService.deleteWorkbasket(workbaskets.get(0).getId());
-
-    // Run taskCleanupJob for deleting completing tasks before running workbasketCleanupJob
-    TaskCleanupJob taskCleanupJob = new TaskCleanupJob(taskanaEngine, null, null);
-    taskCleanupJob.run();
-
-    assertThat(getNumberTaskCompleted(workbaskets.get(0).getId())).isZero();
-
-    WorkbasketCleanupJob workbasketCleanupJob = new WorkbasketCleanupJob(taskanaEngine, null, null);
-    workbasketCleanupJob.run();
-
-    totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
-    assertThat(totalWorkbasketCount).isEqualTo(25);
-  }
-
-  @WithAccessId(user = "admin")
-  @Test
-  void shouldNotCleanWorkbasketMarkedForDeletionIfWorkbasketHasTasks() throws Exception {
-    long totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
-    assertThat(totalWorkbasketCount).isEqualTo(26);
-    List<WorkbasketSummary> workbaskets =
-        workbasketService
-            .createWorkbasketQuery()
-            .keyIn("TEAMLEAD-1")
-            .orderByKey(BaseQuery.SortDirection.ASCENDING)
-            .list();
-
-    assertThat(getNumberTaskCompleted(workbaskets.get(0).getId())).isPositive();
-
-    // Workbasket with completed task will be marked for deletion.
-    workbasketService.deleteWorkbasket(workbaskets.get(0).getId());
-
-    WorkbasketCleanupJob job = new WorkbasketCleanupJob(taskanaEngine, null, null);
-    job.run();
-
-    totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
-    assertThat(totalWorkbasketCount).isEqualTo(26);
-  }
-
-  @WithAccessId(user = "admin")
-  @Test
-  void should_DeleteOldWorkbasketCleanupJobs_When_InitializingSchedule() throws Exception {
-
-    for (int i = 0; i < 10; i++) {
-      ScheduledJob job = new ScheduledJob();
-      job.setType(WorkbasketCleanupJob.class.getName());
-      taskanaEngine.getJobService().createJob(job);
-      job.setType(TaskRefreshJob.class.getName());
-      taskanaEngine.getJobService().createJob(job);
-      job.setType(ClassificationChangedJob.class.getName());
-      taskanaEngine.getJobService().createJob(job);
-    }
-
-    List<ScheduledJob> jobsToRun = getJobMapper(taskanaEngine).findJobsToRun(Instant.now());
-
-    assertThat(jobsToRun).hasSize(30);
-
-    List<ScheduledJob> workbasketCleanupJobs =
-        jobsToRun.stream()
-            .filter(
-                scheduledJob -> scheduledJob.getType().equals(WorkbasketCleanupJob.class.getName()))
-            .collect(Collectors.toList());
-
-    AbstractTaskanaJob.initializeSchedule(taskanaEngine, WorkbasketCleanupJob.class);
-
-    jobsToRun = getJobMapper(taskanaEngine).findJobsToRun(Instant.now());
-
-    assertThat(jobsToRun).doesNotContainAnyElementsOf(workbasketCleanupJobs);
-  }
-
-  private long getNumberTaskNotCompleted(String workbasketId) {
-    return taskService
-        .createTaskQuery()
-        .workbasketIdIn(workbasketId)
-        .stateNotIn(TaskState.COMPLETED)
-        .count();
-  }
-
-  private long getNumberTaskCompleted(String workbasketId) {
-    return taskService
-        .createTaskQuery()
-        .workbasketIdIn(workbasketId)
-        .stateIn(TaskState.COMPLETED)
-        .count();
-  }
-}