TSK-1829: refactor testSetPlannedPropertyOnAllTasks

lib/taskana-core-test/src/test/java/acceptance/ArchitectureTest.java

@@ -555,9 +555,9 @@ class ArchitectureTest {
                 SimpleConditionEvent.violated(
                     item,
                     String.format(
-                        "Field '%s' should not have any modifier "
+                        "Field '%s' in '%s' should not have any modifier, "
                             + "except for static fields, which have to be private",
-                        field.getFullName())));
+                        field.getFullName(), item.getFullName())));
           }
         }
       }

lib/taskana-core-test/src/test/java/acceptance/task/ServiceLevelOfAllTasksAccTest.java

@@ -0,0 +1,222 @@
+package acceptance.task;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification;
+import static pro.taskana.testapi.DefaultTestEntities.defaultTestObjectReference;
+import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket;
+
+import java.time.Duration;
+import java.time.Instant;
+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.BulkOperationResults;
+import pro.taskana.common.api.TaskanaEngine;
+import pro.taskana.common.api.WorkingDaysToDaysConverter;
+import pro.taskana.common.api.exceptions.TaskanaException;
+import pro.taskana.task.api.TaskService;
+import pro.taskana.task.api.models.Attachment;
+import pro.taskana.task.api.models.ObjectReference;
+import pro.taskana.task.api.models.TaskSummary;
+import pro.taskana.testapi.TaskanaInject;
+import pro.taskana.testapi.TaskanaIntegrationTest;
+import pro.taskana.testapi.builder.TaskAttachmentBuilder;
+import pro.taskana.testapi.builder.TaskBuilder;
+import pro.taskana.testapi.builder.WorkbasketAccessItemBuilder;
+import pro.taskana.testapi.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketPermission;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.models.WorkbasketSummary;
+
+/**
+ * Acceptance test for changing the {@linkplain pro.taskana.task.api.models.Task#getPlanned()
+ * planned} Instant of {@linkplain pro.taskana.task.api.models.Task Tasks} in bulk.
+ */
+@TaskanaIntegrationTest
+class ServiceLevelOfAllTasksAccTest {
+
+  private static final String SMALL_CLASSIFICATION_SERVICE_LEVEL = "P2D";
+  private static final String GREAT_CLASSIFICATION_SERVICE_LEVEL = "P7D";
+
+  @TaskanaInject TaskanaEngine taskanaEngine;
+  @TaskanaInject TaskService taskService;
+  @TaskanaInject WorkbasketService workbasketService;
+  @TaskanaInject ClassificationService classificationService;
+
+  ClassificationSummary classificationSummarySmallServiceLevel;
+  ClassificationSummary classificationSummaryGreatServiceLevel;
+  Attachment attachmentSummarySmallServiceLevel;
+  Attachment attachmentSummaryGreatServiceLevel;
+  WorkbasketSummary defaultWorkbasketSummary;
+  ObjectReference defaultObjectReference;
+  WorkingDaysToDaysConverter converter;
+
+  @WithAccessId(user = "businessadmin")
+  @BeforeAll
+  void setup() throws Exception {
+    classificationSummarySmallServiceLevel =
+        defaultTestClassification()
+            .serviceLevel(SMALL_CLASSIFICATION_SERVICE_LEVEL)
+            .buildAndStoreAsSummary(classificationService);
+    classificationSummaryGreatServiceLevel =
+        defaultTestClassification()
+            .serviceLevel(GREAT_CLASSIFICATION_SERVICE_LEVEL)
+            .buildAndStoreAsSummary(classificationService);
+
+    defaultObjectReference = defaultTestObjectReference().build();
+
+    attachmentSummarySmallServiceLevel =
+        TaskAttachmentBuilder.newAttachment()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .objectReference(defaultObjectReference)
+            .build();
+    attachmentSummaryGreatServiceLevel =
+        TaskAttachmentBuilder.newAttachment()
+            .classificationSummary(classificationSummaryGreatServiceLevel)
+            .objectReference(defaultObjectReference)
+            .build();
+
+    defaultWorkbasketSummary = defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
+    WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
+        .workbasketId(defaultWorkbasketSummary.getId())
+        .accessId("user-1-1")
+        .permission(WorkbasketPermission.OPEN)
+        .permission(WorkbasketPermission.READ)
+        .permission(WorkbasketPermission.APPEND)
+        .buildAndStore(workbasketService);
+    converter = taskanaEngine.getWorkingDaysToDaysConverter();
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @Test
+  void should_SetPlannedOnMultipleTasks() throws Exception {
+    Instant planned = Instant.parse("2020-05-03T07:00:00.000Z");
+    TaskSummary task1 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task2 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .attachments(attachmentSummaryGreatServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task3 =
+        createDefaultTask()
+            .classificationSummary(classificationSummaryGreatServiceLevel)
+            .attachments(attachmentSummarySmallServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    List<String> taskIds = List.of(task1.getId(), task2.getId(), task3.getId());
+
+    BulkOperationResults<String, TaskanaException> bulkLog =
+        taskService.setPlannedPropertyOfTasks(planned, taskIds);
+
+    assertThat(bulkLog.containsErrors()).isFalse();
+    List<TaskSummary> result =
+        taskService.createTaskQuery().idIn(task1.getId(), task2.getId(), task3.getId()).list();
+    assertThat(result).extracting(TaskSummary::getPlanned).containsOnly(planned);
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @Test
+  void should_ChangeDue_When_SettingPlannedAndClassificationHasSmallerServiceLevel()
+      throws Exception {
+    Instant planned = Instant.parse("2020-05-03T07:00:00.000Z");
+    TaskSummary task1 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .attachments(attachmentSummaryGreatServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task2 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .buildAndStoreAsSummary(taskService);
+    List<String> taskIds = List.of(task1.getId(), task2.getId());
+
+    BulkOperationResults<String, TaskanaException> bulkLog =
+        taskService.setPlannedPropertyOfTasks(planned, taskIds);
+
+    assertThat(bulkLog.containsErrors()).isFalse();
+    List<TaskSummary> result =
+        taskService.createTaskQuery().idIn(task1.getId(), task2.getId()).list();
+    assertThat(result)
+        .extracting(TaskSummary::getDue)
+        .containsOnly(
+            converter.addWorkingDaysToInstant(
+                planned, Duration.parse(SMALL_CLASSIFICATION_SERVICE_LEVEL)));
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @Test
+  void should_ChangeDue_When_SettingPlannedAndAttachmentHasSmallerOrEqualServiceLevel()
+      throws Exception {
+    Instant planned = Instant.parse("2020-05-03T07:00:00.000Z");
+    TaskSummary task1 =
+        createDefaultTask()
+            .classificationSummary(classificationSummaryGreatServiceLevel)
+            .attachments(attachmentSummarySmallServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task2 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .attachments(attachmentSummarySmallServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    List<String> taskIds = List.of(task1.getId(), task2.getId());
+
+    BulkOperationResults<String, TaskanaException> bulkLog =
+        taskService.setPlannedPropertyOfTasks(planned, taskIds);
+
+    assertThat(bulkLog.containsErrors()).isFalse();
+    List<TaskSummary> result =
+        taskService.createTaskQuery().idIn(task1.getId(), task2.getId()).list();
+    assertThat(result)
+        .extracting(TaskSummary::getDue)
+        .containsOnly(
+            converter.addWorkingDaysToInstant(
+                planned, Duration.parse(SMALL_CLASSIFICATION_SERVICE_LEVEL)));
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @Test
+  void should_ChangeDue_When_SettingPlannedAndUsingDifferentServiceLevels() throws Exception {
+    Instant planned = Instant.parse("2020-05-03T07:00:00.000Z");
+    TaskSummary task1 =
+        createDefaultTask()
+            .classificationSummary(classificationSummaryGreatServiceLevel)
+            .attachments(attachmentSummarySmallServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task2 =
+        createDefaultTask()
+            .classificationSummary(classificationSummarySmallServiceLevel)
+            .attachments(attachmentSummaryGreatServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    TaskSummary task3 =
+        createDefaultTask()
+            .classificationSummary(classificationSummaryGreatServiceLevel)
+            .attachments(attachmentSummaryGreatServiceLevel.copy())
+            .buildAndStoreAsSummary(taskService);
+    List<String> taskIds = List.of(task1.getId(), task2.getId(), task3.getId());
+
+    BulkOperationResults<String, TaskanaException> bulkLog =
+        taskService.setPlannedPropertyOfTasks(planned, taskIds);
+
+    assertThat(bulkLog.containsErrors()).isFalse();
+    List<TaskSummary> result =
+        taskService.createTaskQuery().idIn(task1.getId(), task2.getId(), task3.getId()).list();
+    assertThat(result)
+        .extracting(TaskSummary::getDue)
+        .containsOnly(
+            converter.addWorkingDaysToInstant(
+                planned, Duration.parse(SMALL_CLASSIFICATION_SERVICE_LEVEL)),
+            converter.addWorkingDaysToInstant(
+                planned, Duration.parse(GREAT_CLASSIFICATION_SERVICE_LEVEL)));
+  }
+
+  private TaskBuilder createDefaultTask() {
+    return (TaskBuilder.newTask()
+        .workbasketSummary(defaultWorkbasketSummary)
+        .primaryObjRef(defaultObjectReference));
+  }
+}

lib/taskana-core/src/test/java/acceptance/task/ServiceLevelPriorityAccTest.java

@@ -12,8 +12,6 @@ import java.time.ZoneId;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.assertj.core.data.TemporalUnitWithinOffset;
 import org.junit.jupiter.api.Test;
@@ -31,7 +29,6 @@ import pro.taskana.common.test.security.WithAccessId;
 import pro.taskana.task.api.TaskService;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
 import pro.taskana.task.api.models.Task;
-import pro.taskana.task.api.models.TaskSummary;
 
 /** Acceptance test for all "create task" scenarios. */
 @ExtendWith(JaasExtension.class)
@@ -603,38 +600,4 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
     assertThat(task.getDue()).isEqualTo(getInstant("2020-04-14T07:00:00")); // Tuesday
     assertThat(task.getPlanned()).isEqualTo(getInstant("2020-04-09T07:00:00")); // Thursday
   }
-
-  @WithAccessId(user = "admin")
-  @Test
-  void testSetPlannedPropertyOnAllTasks() throws Exception {
-    resetDb(false);
-
-    Instant planned = getInstant("2020-05-03T07:00:00");
-    List<TaskSummary> allTasks = taskService.createTaskQuery().list();
-    // Now update each task with updateTask() and new planned
-    final List<TaskSummary> individuallyUpdatedTasks = new ArrayList<>();
-    allTasks.forEach(t -> individuallyUpdatedTasks.add(getUpdatedTaskSummary(t, planned)));
-    // reset DB and do the same with bulk update
-    resetDb(false);
-    List<String> taskIds = allTasks.stream().map(TaskSummary::getId).collect(Collectors.toList());
-    BulkOperationResults<String, TaskanaException> bulkLog =
-        taskService.setPlannedPropertyOfTasks(planned, taskIds);
-    // check that there was no error and compare the result of the 2 operations
-    assertThat(bulkLog.containsErrors()).isFalse();
-    Map<String, Instant> bulkUpdatedTaskMap =
-        taskService.createTaskQuery().list().stream()
-            .collect(Collectors.toMap(TaskSummary::getId, TaskSummary::getDue));
-    individuallyUpdatedTasks.forEach(
-        t -> assertThat(t.getDue().equals(bulkUpdatedTaskMap.get(t.getId()))));
-  }
-
-  private TaskSummary getUpdatedTaskSummary(TaskSummary t, Instant planned) {
-    try {
-      Task task = taskService.getTask(t.getId());
-      task.setPlanned(planned);
-      return taskService.updateTask(task);
-    } catch (Exception e) {
-      return null;
-    }
-  }
 }