From 131c1f0cb90071b3183b23062564506c8a35a5ff Mon Sep 17 00:00:00 2001 From: Yakup Ensar Evli <54323073+ensarevlideveloper@users.noreply.github.com> Date: Thu, 11 Aug 2022 11:05:03 +0200 Subject: [PATCH] TSK-1866: Refactor UpdateClassificationAccTest to use Test-API Compressed UpdateTaskPriority/ServiceLevel-Test. Check error messages. Cleaned comments. Reordered some methods. Move test to taskana-core-test according to new structure. --- .../update/UpdateClassificationAccTest.java | 815 ++++++++++++++++++ .../update/UpdateClassificationAccTest.java | 525 ----------- 2 files changed, 815 insertions(+), 525 deletions(-) create mode 100644 lib/taskana-core-test/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java delete mode 100644 lib/taskana-core/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java diff --git a/lib/taskana-core-test/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java b/lib/taskana-core-test/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java new file mode 100644 index 000000000..6860c6dba --- /dev/null +++ b/lib/taskana-core-test/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java @@ -0,0 +1,815 @@ +package acceptance.classification.update; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestObjectReference; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket; +import static pro.taskana.testapi.builder.TaskBuilder.newTask; + +import java.time.Duration; +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestFactory; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.api.TestTemplate; +import org.junit.jupiter.api.function.ThrowingConsumer; + +import pro.taskana.classification.api.ClassificationCustomField; +import pro.taskana.classification.api.ClassificationService; +import pro.taskana.classification.api.exceptions.ClassificationNotFoundException; +import pro.taskana.classification.api.models.Classification; +import pro.taskana.classification.api.models.ClassificationSummary; +import pro.taskana.classification.internal.models.ClassificationImpl; +import pro.taskana.common.api.TaskanaEngine; +import pro.taskana.common.api.TaskanaRole; +import pro.taskana.common.api.WorkingDaysToDaysConverter; +import pro.taskana.common.api.exceptions.ConcurrencyException; +import pro.taskana.common.api.exceptions.InvalidArgumentException; +import pro.taskana.common.api.exceptions.MismatchedRoleException; +import pro.taskana.common.api.security.CurrentUserContext; +import pro.taskana.common.internal.jobs.JobRunner; +import pro.taskana.common.internal.util.Pair; +import pro.taskana.task.api.TaskService; +import pro.taskana.task.api.models.Attachment; +import pro.taskana.task.api.models.Task; +import pro.taskana.task.internal.models.TaskImpl; +import pro.taskana.testapi.TaskanaInject; +import pro.taskana.testapi.TaskanaIntegrationTest; +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 all "update classification" scenarios. */ +@TaskanaIntegrationTest +class UpdateClassificationAccTest { + @TaskanaInject ClassificationService classificationService; + @TaskanaInject TaskanaEngine taskanaEngine; + @TaskanaInject TaskService taskService; + @TaskanaInject WorkbasketService workbasketService; + @TaskanaInject WorkingDaysToDaysConverter converter; + @TaskanaInject CurrentUserContext currentUserContext; + + @WithAccessId(user = "businessadmin") + @Test + void should_SetFieldsCorrectly_When_TryingToUpdateClassification() throws Exception { + Classification parentClassification = + defaultTestClassification().buildAndStore(classificationService); + Classification classification = + defaultTestClassification().type("TASK").buildAndStore(classificationService); + final Instant createdBefore = classification.getCreated(); + final Instant modifiedBefore = classification.getModified(); + + classification.setApplicationEntryPoint("newEntrypoint"); + classification.setCategory("PROCESS"); + classification.setCustomField(ClassificationCustomField.CUSTOM_1, "newCustom1"); + classification.setCustomField(ClassificationCustomField.CUSTOM_2, "newCustom2"); + classification.setCustomField(ClassificationCustomField.CUSTOM_3, "newCustom3"); + classification.setCustomField(ClassificationCustomField.CUSTOM_4, "newCustom4"); + classification.setCustomField(ClassificationCustomField.CUSTOM_5, "newCustom5"); + classification.setCustomField(ClassificationCustomField.CUSTOM_6, "newCustom6"); + classification.setCustomField(ClassificationCustomField.CUSTOM_7, "newCustom7"); + classification.setCustomField(ClassificationCustomField.CUSTOM_8, "newCustom8"); + classification.setDescription("newDescription"); + classification.setIsValidInDomain(false); + classification.setName("newName"); + classification.setParentId(parentClassification.getId()); + classification.setParentKey(parentClassification.getKey()); + classification.setPriority(1000); + classification.setServiceLevel("P3D"); + classificationService.updateClassification(classification); + + Classification updatedClassification = + classificationService.getClassification(classification.getKey(), "DOMAIN_A"); + ClassificationImpl expectedClassification = + (ClassificationImpl) + defaultTestClassification() + .type("TASK") + .applicationEntryPoint("newEntrypoint") + .category("PROCESS") + .customAttribute(ClassificationCustomField.CUSTOM_1, "newCustom1") + .customAttribute(ClassificationCustomField.CUSTOM_2, "newCustom2") + .customAttribute(ClassificationCustomField.CUSTOM_3, "newCustom3") + .customAttribute(ClassificationCustomField.CUSTOM_4, "newCustom4") + .customAttribute(ClassificationCustomField.CUSTOM_5, "newCustom5") + .customAttribute(ClassificationCustomField.CUSTOM_6, "newCustom6") + .customAttribute(ClassificationCustomField.CUSTOM_7, "newCustom7") + .customAttribute(ClassificationCustomField.CUSTOM_8, "newCustom8") + .description("newDescription") + .isValidInDomain(false) + .name("newName") + .parentId(parentClassification.getId()) + .parentKey(parentClassification.getKey()) + .priority(1000) + .serviceLevel("P3D") + .created(createdBefore) + .modified(updatedClassification.getModified()) + .buildAndStore(classificationService); + expectedClassification.setKey(updatedClassification.getKey()); + expectedClassification.setId(updatedClassification.getId()); + + assertThat(expectedClassification).hasNoNullFieldsOrProperties(); + assertThat(modifiedBefore).isBefore(classification.getModified()); + assertThat(updatedClassification).isEqualTo(expectedClassification); + } + + private String createTaskWithExistingClassification(ClassificationSummary classificationSummary) + throws Exception { + WorkbasketSummary workbasketSummary = + defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService); + WorkbasketAccessItemBuilder.newWorkbasketAccessItem() + .workbasketId(workbasketSummary.getId()) + .accessId(currentUserContext.getUserid()) + .permission(WorkbasketPermission.OPEN) + .permission(WorkbasketPermission.READ) + .permission(WorkbasketPermission.APPEND) + .buildAndStore(workbasketService, "businessadmin"); + + return newTask() + .classificationSummary(classificationSummary) + .workbasketSummary(workbasketSummary) + .primaryObjRef(defaultTestObjectReference().build()) + .buildAndStore(taskService) + .getId(); + } + + private List createTasksWithExistingClassificationInAttachment( + ClassificationSummary classificationSummary, String serviceLevel, int priority, int amount) + throws Exception { + List taskList = new ArrayList<>(); + WorkbasketSummary workbasketSummary = + defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService); + WorkbasketAccessItemBuilder.newWorkbasketAccessItem() + .workbasketId(workbasketSummary.getId()) + .accessId(currentUserContext.getUserid()) + .permission(WorkbasketPermission.OPEN) + .permission(WorkbasketPermission.READ) + .permission(WorkbasketPermission.APPEND) + .buildAndStore(workbasketService, "businessadmin"); + ClassificationSummary classificationSummaryWithSpecifiedServiceLevel = + defaultTestClassification() + .serviceLevel(serviceLevel) + .priority(priority) + .buildAndStoreAsSummary(classificationService); + for (int i = 0; i < amount; i++) { + Attachment attachment = taskService.newAttachment(); + attachment.setClassificationSummary(classificationSummary); + attachment.setObjectReference(defaultTestObjectReference().build()); + taskList.add( + newTask() + .classificationSummary(classificationSummaryWithSpecifiedServiceLevel) + .workbasketSummary(workbasketSummary) + .primaryObjRef(defaultTestObjectReference().build()) + .attachments(attachment) + .buildAndStore(taskService) + .getId()); + } + return taskList; + } + + @TestInstance(Lifecycle.PER_CLASS) + @Nested + class UpdatePriorityAndServiceLevelTest { + + @WithAccessId(user = "businessadmin") + @Test + void should_NotThrowException_When_UpdatingClassificationWithEmptyServiceLevel() + throws Exception { + Classification classification = + defaultTestClassification().serviceLevel("P1D").buildAndStore(classificationService); + classification.setServiceLevel(""); + assertThatCode(() -> classificationService.updateClassification(classification)) + .doesNotThrowAnyException(); + assertThat(classificationService.getClassification(classification.getId()).getServiceLevel()) + .isEqualTo("P0D"); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream + should_SetDefaultServiceLevel_When_TryingToUpdateClassificationWithMissingServiceLevel() + throws Exception { + Classification classification = + defaultTestClassification().serviceLevel("P1D").buildAndStore(classificationService); + List> inputList = + List.of(Pair.of(classification, null), Pair.of(classification, "")); + + ThrowingConsumer> test = + input -> { + input.getLeft().setServiceLevel(input.getRight()); + classificationService.updateClassification(input.getLeft()); + assertThat( + classificationService + .getClassification(input.getLeft().getId()) + .getServiceLevel()) + .isEqualTo("P0D"); + }; + + return DynamicTest.stream( + inputList.iterator(), i -> String.format("for %s", i.getRight()), test); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_UpdateTaskServiceLevel_When_UpdateClassificationInTask() throws Exception { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P13D") + .buildAndStore(classificationService); + final List directLinkedTask = + List.of(createTaskWithExistingClassification(classification.asSummary())); + + classification.setServiceLevel("P15D"); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties(before, directLinkedTask, taskService, converter, 15, 1); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_UpdateTaskPriority_When_UpdateClassificationInTask() throws Exception { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P13D") + .buildAndStore(classificationService); + final List directLinkedTask = + List.of(createTaskWithExistingClassification(classification.asSummary())); + + classification.setPriority(1000); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties(before, directLinkedTask, taskService, converter, 13, 1000); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_UpdateTaskPriorityAndServiceLevel_When_UpdateClassificationInTask() + throws Exception { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P13D") + .buildAndStore(classificationService); + final List directLinkedTask = + List.of(createTaskWithExistingClassification(classification.asSummary())); + + classification.setServiceLevel("P15D"); + classification.setPriority(1000); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties(before, directLinkedTask, taskService, converter, 15, 1000); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream should_UpdateTaskServiceLevel_When_UpdateClassificationInAttachment() { + List> inputs = + List.of(Pair.of("P5D", 2), Pair.of("P8D", 3), Pair.of("P16D", 4)); + + List> outputs = List.of(Pair.of(1, 2), Pair.of(1, 3), Pair.of(1, 4)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P15D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 5); + + classification.setServiceLevel("P1D"); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream should_NotUpdateTaskServiceLevel_When_UpdateClassificationInAttachment() { + List> inputs = + List.of(Pair.of("P5D", 2), Pair.of("P8D", 3), Pair.of("P14D", 4)); + + List> outputs = List.of(Pair.of(5, 2), Pair.of(8, 3), Pair.of(14, 4)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P1D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 5); + + classification.setServiceLevel("P15D"); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream should_UpdateTaskPriority_When_UpdateClassificationInAttachment() { + List> inputs = + List.of(Pair.of("P1D", 1), Pair.of("P8D", 2), Pair.of("P14D", 999)); + + List> outputs = + List.of(Pair.of(1, 1000), Pair.of(8, 1000), Pair.of(14, 1000)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P13D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 5); + + classification.setServiceLevel("P15D"); + classification.setPriority(1000); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream should_NotUpdateTaskPriority_When_UpdateClassificationInAttachment() { + List> inputs = + List.of(Pair.of("P1D", 2), Pair.of("P8D", 3), Pair.of("P14D", 999)); + + List> outputs = + List.of(Pair.of(1, 2), Pair.of(8, 3), Pair.of(14, 999)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1000) + .serviceLevel("P13D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 5); + + classification.setServiceLevel("P15D"); + classification.setPriority(1); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream + should_UpdateTaskPriorityAndServiceLevel_When_UpdateClassificationInAttachment() { + List> inputs = List.of(Pair.of("P1D", 5), Pair.of("P14D", 98)); + + List> outputs = List.of(Pair.of(1, 99), Pair.of(1, 99)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1) + .serviceLevel("P13D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 3); + + classification.setServiceLevel("P1D"); + classification.setPriority(99); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream + should_NotUpdateTaskPriorityAndServiceLevel_When_UpdateClassificationInAttachment() { + List> inputs = List.of(Pair.of("P1D", 5), Pair.of("P14D", 98)); + + List> outputs = List.of(Pair.of(1, 5), Pair.of(14, 98)); + + List, Pair>> zippedTestInputList = + IntStream.range(0, inputs.size()) + .mapToObj(i -> Pair.of(inputs.get(i), outputs.get(i))) + .collect(Collectors.toList()); + + ThrowingConsumer, Pair>> test = + input -> { + final Instant before = Instant.now(); + Classification classification = + defaultTestClassification() + .priority(1000) + .serviceLevel("P1D") + .buildAndStore(classificationService); + ClassificationSummary classificationSummary = classification.asSummary(); + final List indirectLinkedTasks = + createTasksWithExistingClassificationInAttachment( + classificationSummary, + input.getLeft().getLeft(), + input.getLeft().getRight(), + 3); + + classification.setServiceLevel("P15D"); + classification.setPriority(1); + classificationService.updateClassification(classification); + runAssociatedJobs(); + + validateTaskProperties( + before, + indirectLinkedTasks, + taskService, + converter, + input.getRight().getLeft(), + input.getRight().getRight()); + }; + + return DynamicTest.stream( + zippedTestInputList.iterator(), + i -> + String.format( + "for Task with ServiceLevel %s and Priority %s", + i.getLeft().getLeft(), i.getLeft().getRight()), + test); + } + + private void runAssociatedJobs() throws Exception { + Thread.sleep(10); + // run the ClassificationChangedJob + JobRunner runner = new JobRunner(taskanaEngine); + // run the TaskRefreshJob that was scheduled by the ClassificationChangedJob. + runner.runJobs(); + Thread.sleep( + 10); // otherwise the next runJobs call intermittently doesn't find the Job created + // by the previous step (it searches with DueDate < CurrentTime) + runner.runJobs(); + } + + private void validateTaskProperties( + Instant before, + List tasksUpdated, + TaskService taskService, + WorkingDaysToDaysConverter converter, + int serviceLevel, + int priority) + throws Exception { + for (String taskId : tasksUpdated) { + Task task = taskService.getTask(taskId); + + Instant expDue = + converter.addWorkingDaysToInstant(task.getPlanned(), Duration.ofDays(serviceLevel)); + assertThat(task.getModified()) + .describedAs("Task " + task.getId() + " has not been refreshed.") + .isAfter(before); + assertThat(task.getDue()).isEqualTo(expDue); + assertThat(task.getPriority()).isEqualTo(priority); + } + } + } + + @TestInstance(Lifecycle.PER_CLASS) + @Nested + class UpdateClassificationExceptionTest { + /** + * This BeforeAll method is needed for this {@linkplain + * #should_ThrowException_When_UserIsNotAuthorized test} and {@linkplain + * #should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin test} since it can't create an + * own classification. + * + * @throws Exception for errors in the building or reading process of entities. + */ + @WithAccessId(user = "businessadmin") + @BeforeAll + void createClassifications() throws Exception { + defaultTestClassification() + .key("BeforeAllClassification") + .buildAndStore(classificationService); + } + + @Test + void should_ThrowException_When_UserIsNotAuthorized() throws Exception { + Classification classification = + classificationService.getClassification("BeforeAllClassification", "DOMAIN_A"); + classification.setCustomField(ClassificationCustomField.CUSTOM_1, "newCustom1"); + + MismatchedRoleException expectedException = + new MismatchedRoleException( + currentUserContext.getUserid(), TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN); + assertThatThrownBy(() -> classificationService.updateClassification(classification)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + + @WithAccessId(user = "taskadmin") + @WithAccessId(user = "user-1-1") + @TestTemplate + void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() throws Exception { + Classification classification = + classificationService.getClassification("BeforeAllClassification", "DOMAIN_A"); + + classification.setApplicationEntryPoint("updated EntryPoint"); + classification.setName("updated Name"); + + MismatchedRoleException expectedException = + new MismatchedRoleException( + currentUserContext.getUserid(), TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN); + assertThatThrownBy(() -> classificationService.updateClassification(classification)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_ThrowException_When_UpdatingClassificationConcurrently() throws Exception { + Classification classification = + defaultTestClassification().buildAndStore(classificationService); + final Classification classificationSecondUpdate = + classificationService.getClassification( + classification.getKey(), classification.getDomain()); + + classification.setApplicationEntryPoint("Application Entry Point"); + classification.setDescription("Description"); + classification.setName("Name"); + Thread.sleep(20); // to avoid identity of modified timestamps between classification and base + classificationService.updateClassification(classification); + classificationSecondUpdate.setName("Name again"); + classificationSecondUpdate.setDescription("Description again"); + + ConcurrencyException expectedException = + new ConcurrencyException(classificationSecondUpdate.getId()); + assertThatThrownBy( + () -> classificationService.updateClassification(classificationSecondUpdate)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_ThrowException_When_TryingToUpdateClassificationWithInvalidParentId() + throws Exception { + Classification classification = + defaultTestClassification().buildAndStore(classificationService); + + classification.setParentId("NON EXISTING ID"); + + ClassificationNotFoundException expectedException = + new ClassificationNotFoundException("NON EXISTING ID"); + assertThatThrownBy(() -> classificationService.updateClassification(classification)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_ThrowException_When_TryingToUpdateClassificationWithInvalidParentKey() + throws Exception { + Classification classification = + defaultTestClassification().buildAndStore(classificationService); + + classification.setParentKey("NON EXISTING KEY"); + + ClassificationNotFoundException expectedException = + new ClassificationNotFoundException("NON EXISTING KEY", "DOMAIN_A"); + assertThatThrownBy(() -> classificationService.updateClassification(classification)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_ThrowException_When_TryingToUpdateClassificationWithOwnKeyAsParentKey() + throws Exception { + Classification classification = + defaultTestClassification().buildAndStore(classificationService); + + classification.setParentKey(classification.getKey()); + + InvalidArgumentException expectedException = + new InvalidArgumentException( + String.format( + "The Classification '%s' has the same key and parent key", + classification.getName())); + assertThatThrownBy(() -> classificationService.updateClassification(classification)) + .usingRecursiveComparison() + .isEqualTo(expectedException); + } + } + + @TestInstance(Lifecycle.PER_CLASS) + @Nested + class UpdateClassificationCategoryTest { + Classification classification; + Task task; + Instant createdBefore; + Instant modifiedBefore; + + @WithAccessId(user = "businessadmin") + @BeforeEach + void createClassificationAndTask() throws Exception { + classification = + defaultTestClassification() + .category("MANUAL") + .type("TASK") + .buildAndStore(classificationService); + createdBefore = classification.getCreated(); + modifiedBefore = classification.getModified(); + String taskId = createTaskWithExistingClassification(classification.asSummary()); + task = taskService.getTask(taskId); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_UpdateTask_When_UpdatingClassificationCategory() throws Exception { + classification.setCategory("PROCESS"); + classificationService.updateClassification(classification); + final Task updatedTask = taskService.getTask(task.getId()); + + TaskImpl expectedUpdatedTask = (TaskImpl) task.copy(); + expectedUpdatedTask.setId(task.getId()); + expectedUpdatedTask.setClassificationCategory("PROCESS"); + expectedUpdatedTask.setClassificationSummary( + classificationService.getClassification(classification.getId()).asSummary()); + expectedUpdatedTask.setExternalId(task.getExternalId()); + assertThat(expectedUpdatedTask) + .usingRecursiveComparison() + .ignoringFields("modified") + .isEqualTo(updatedTask); + assertThat(expectedUpdatedTask.getModified()).isAfterOrEqualTo(modifiedBefore); + } + + @WithAccessId(user = "businessadmin") + @Test + void should_UpdateClassification_When_UpdatingClassificationCategory() throws Exception { + classification.setCategory("PROCESS"); + classificationService.updateClassification(classification); + + Classification updatedClassification = + classificationService.getClassification(classification.getId()); + assertThat(updatedClassification) + .usingRecursiveComparison() + .ignoringFields("modified") + .isEqualTo(classification); + assertThat(updatedClassification.getModified()).isAfterOrEqualTo(modifiedBefore); + } + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java deleted file mode 100644 index 56d05df28..000000000 --- a/lib/taskana-core/src/test/java/acceptance/classification/update/UpdateClassificationAccTest.java +++ /dev/null @@ -1,525 +0,0 @@ -package acceptance.classification.update; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatCode; -import static org.assertj.core.api.Assertions.assertThatThrownBy; - -import acceptance.AbstractAccTest; -import java.time.Duration; -import java.time.Instant; -import java.util.List; -import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestTemplate; -import org.junit.jupiter.api.extension.ExtendWith; - -import pro.taskana.classification.api.ClassificationCustomField; -import pro.taskana.classification.api.ClassificationService; -import pro.taskana.classification.api.exceptions.ClassificationNotFoundException; -import pro.taskana.classification.api.models.Classification; -import pro.taskana.common.api.WorkingDaysToDaysConverter; -import pro.taskana.common.api.exceptions.ConcurrencyException; -import pro.taskana.common.api.exceptions.InvalidArgumentException; -import pro.taskana.common.api.exceptions.NotAuthorizedException; -import pro.taskana.common.internal.jobs.JobRunner; -import pro.taskana.common.test.security.JaasExtension; -import pro.taskana.common.test.security.WithAccessId; -import pro.taskana.task.api.TaskService; -import pro.taskana.task.api.models.Task; -import pro.taskana.task.internal.models.TaskImpl; - -/** Acceptance test for all "update classification" scenarios. */ -@ExtendWith(JaasExtension.class) -class UpdateClassificationAccTest extends AbstractAccTest { - - private final ClassificationService classificationService = - taskanaEngine.getClassificationService(); - - @WithAccessId(user = "admin") - @Test - void should_SetDefaultServiceLevel_When_TryingToUpdateClassificationWithMissingServiceLevel() - throws Exception { - Classification classification = - classificationService.newClassification("Key1230", "DOMAIN_A", "TASK"); - classification.setServiceLevel("P1D"); - classification = classificationService.createClassification(classification); - classification.setServiceLevel(null); - classification = classificationService.updateClassification(classification); - assertThat(classification.getServiceLevel()).isEqualTo("P0D"); - classification.setServiceLevel(""); - classification = classificationService.updateClassification(classification); - assertThat(classification.getServiceLevel()).isEqualTo("P0D"); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassification() throws Exception { - String newName = "updated Name"; - String newEntryPoint = "updated EntryPoint"; - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - final Instant createdBefore = classification.getCreated(); - final Instant modifiedBefore = classification.getModified(); - - classification.setApplicationEntryPoint(newEntryPoint); - classification.setCategory("PROCESS"); - classification.setCustomField(ClassificationCustomField.CUSTOM_1, "newCustom1"); - classification.setCustomField(ClassificationCustomField.CUSTOM_2, "newCustom2"); - classification.setCustomField(ClassificationCustomField.CUSTOM_3, "newCustom3"); - classification.setCustomField(ClassificationCustomField.CUSTOM_4, "newCustom4"); - classification.setCustomField(ClassificationCustomField.CUSTOM_5, "newCustom5"); - classification.setCustomField(ClassificationCustomField.CUSTOM_6, "newCustom6"); - classification.setCustomField(ClassificationCustomField.CUSTOM_7, "newCustom7"); - classification.setCustomField(ClassificationCustomField.CUSTOM_8, "newCustom8"); - classification.setDescription("newDescription"); - classification.setIsValidInDomain(false); - classification.setName(newName); - classification.setParentId("CLI:100000000000000000000000000000000004"); - classification.setParentKey("L11010"); - classification.setPriority(1000); - classification.setServiceLevel("P3D"); - - classificationService.updateClassification(classification); - - // Get and check the new value - Classification updatedClassification = - classificationService.getClassification("T2100", "DOMAIN_A"); - assertThat(updatedClassification).isNotNull(); - assertThat(updatedClassification.getName()).isEqualTo(newName); - assertThat(updatedClassification.getApplicationEntryPoint()).isEqualTo(newEntryPoint); - assertThat(updatedClassification.getCreated()).isEqualTo(createdBefore); - assertThat(modifiedBefore).isBefore(updatedClassification.getModified()); - } - - @Test - void should_ThrowException_When_UserIsNotAuthorized() throws Exception { - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - classification.setCustomField(ClassificationCustomField.CUSTOM_1, "newCustom1"); - ThrowingCallable call = () -> classificationService.updateClassification(classification); - assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class); - } - - @WithAccessId(user = "taskadmin") - @WithAccessId(user = "user-1-1") - @TestTemplate - void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() throws Exception { - - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - - classification.setApplicationEntryPoint("updated EntryPoint"); - classification.setName("updated Name"); - - ThrowingCallable updateClassificationCall = - () -> classificationService.updateClassification(classification); - assertThatThrownBy(updateClassificationCall).isInstanceOf(NotAuthorizedException.class); - } - - @WithAccessId(user = "businessadmin", groups = "user-1-1") // to read the task - @Test - void testUpdateTaskOnClassificationKeyCategoryChange() throws Exception { - setupTest(); - TaskImpl beforeTask = - (TaskImpl) - taskanaEngine.getTaskService().getTask("TKI:000000000000000000000000000000000000"); - - Classification classification = - classificationService.getClassification( - beforeTask.getClassificationSummary().getKey(), beforeTask.getDomain()); - classification.setCategory("PROCESS"); - final Instant createdBefore = classification.getCreated(); - final Instant modifiedBefore = classification.getModified(); - classification = taskanaEngine.getClassificationService().updateClassification(classification); - - TaskImpl updatedTask = - (TaskImpl) - taskanaEngine.getTaskService().getTask("TKI:000000000000000000000000000000000000"); - assertThat(beforeTask.getClassificationCategory()) - .isNotEqualTo(updatedTask.getClassificationCategory()); - assertThat(beforeTask.getClassificationSummary().getCategory()) - .isNotEqualTo(updatedTask.getClassificationSummary().getCategory()); - assertThat(updatedTask.getClassificationCategory()).isEqualTo("PROCESS"); - assertThat(updatedTask.getClassificationSummary().getCategory()).isEqualTo("PROCESS"); - assertThat(classification.getCreated()).isEqualTo(createdBefore); - // isBeforeOrEquals in case of too fast execution - assertThat(modifiedBefore).isBeforeOrEqualTo(classification.getModified()); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassificationNotLatestAnymore() throws Exception { - Classification base = classificationService.getClassification("T2100", "DOMAIN_A"); - final Classification classification = - classificationService.getClassification("T2100", "DOMAIN_A"); - - // UPDATE BASE - base.setApplicationEntryPoint("SOME CHANGED POINT"); - base.setDescription("AN OTHER DESCRIPTION"); - base.setName("I AM UPDATED"); - Thread.sleep(20); // to avoid identity of modified timestamps between classification and base - classificationService.updateClassification(base); - - classification.setName("NOW IT'S MY TURN"); - classification.setDescription("IT SHOULD BE TO LATE..."); - ThrowingCallable call = () -> classificationService.updateClassification(classification); - assertThatThrownBy(call).isInstanceOf(ConcurrencyException.class); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassificationParentIdToInvalid() throws Exception { - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - classification.setParentId("ID WHICH CANT BE FOUND"); - ThrowingCallable call = () -> classificationService.updateClassification(classification); - assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassificationParentKeyToInvalid() throws Exception { - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - classification.setParentKey("KEY WHICH CANT BE FOUND"); - ThrowingCallable call = () -> classificationService.updateClassification(classification); - assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class); - } - - @WithAccessId(user = "admin") - @Test - void testUpdateClassificationPrioServiceLevel() throws Exception { - final Instant before = Instant.now(); - Classification classification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - final Instant modifiedBefore = classification.getModified(); - classification.setPriority(1000); - classification.setServiceLevel("P15D"); - - updateClassificationAndRunAssociatedJobs(classification); - // Get and check the new value - Classification updatedClassification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - assertThat(updatedClassification).isNotNull(); - - assertThat(modifiedBefore.isAfter(updatedClassification.getModified())).isFalse(); - // TODO - resume old behaviour after attachment query is possible. - TaskService taskService = taskanaEngine.getTaskService(); - - List tasksWithP1D = - List.of( - "TKI:000000000000000000000000000000000054", - "TKI:000000000000000000000000000000000055", - "TKI:000000000000000000000000000000000000", - "TKI:000000000000000000000000000000000053"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithP1D, taskService, converter, 1, 1000); - - List tasksWithP8D = List.of("TKI:000000000000000000000000000000000008"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithP8D, taskService, converter, 8, 1000); - - List tasksWithP14D = List.of("TKI:000000000000000000000000000000000010"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithP14D, taskService, converter, 14, 1000); - - List tasksWithP15D = - List.of( - "TKI:000000000000000000000000000000000003", - "TKI:000000000000000000000000000000000004", - "TKI:000000000000000000000000000000000005", - "TKI:000000000000000000000000000000000006", - "TKI:000000000000000000000000000000000007", - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000012", - "TKI:000000000000000000000000000000000013", - "TKI:000000000000000000000000000000000014", - "TKI:000000000000000000000000000000000015", - "TKI:000000000000000000000000000000000016", - "TKI:000000000000000000000000000000000017", - "TKI:000000000000000000000000000000000018", - "TKI:000000000000000000000000000000000019", - "TKI:000000000000000000000000000000000020", - "TKI:000000000000000000000000000000000021", - "TKI:000000000000000000000000000000000022", - "TKI:000000000000000000000000000000000023", - "TKI:000000000000000000000000000000000024", - "TKI:000000000000000000000000000000000025", - "TKI:000000000000000000000000000000000026", - "TKI:000000000000000000000000000000000027", - "TKI:000000000000000000000000000000000028", - "TKI:000000000000000000000000000000000029", - "TKI:000000000000000000000000000000000030", - "TKI:000000000000000000000000000000000031", - "TKI:000000000000000000000000000000000032", - "TKI:000000000000000000000000000000000033", - "TKI:000000000000000000000000000000000034", - "TKI:000000000000000000000000000000000035", - "TKI:000000000000000000000000000000000100", - "TKI:000000000000000000000000000000000101", - "TKI:000000000000000000000000000000000102", - "TKI:000000000000000000000000000000000103"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithP15D, taskService, converter, 15, 1000); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassificationWithSameKeyAndParentKey() throws Exception { - - Classification classification = classificationService.getClassification("T2100", "DOMAIN_A"); - - classification.setParentKey(classification.getKey()); - ThrowingCallable call = () -> classificationService.updateClassification(classification); - assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class); - } - - @WithAccessId(user = "businessadmin") - @Test - void testUpdateClassificationWithEmptyServiceLevel() throws Exception { - - Classification classification = - classificationService.newClassification("Key=0818", "DOMAIN_A", "TASK"); - classification.setServiceLevel("P1D"); - Classification created = classificationService.createClassification(classification); - created.setServiceLevel(""); - - assertThatCode(() -> classificationService.updateClassification(created)) - .doesNotThrowAnyException(); - } - - @WithAccessId(user = "admin") - @Test - void testUpdateClassificationChangePriority() throws Exception { - final Instant before = Instant.now(); - Classification classification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - final Instant modifiedBefore = classification.getModified(); - - classification.setPriority(99); - classification.setServiceLevel("P1D"); - - updateClassificationAndRunAssociatedJobs(classification); - // Get and check the new value - Classification updatedClassification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - assertThat(updatedClassification).isNotNull(); - assertThat(modifiedBefore.isAfter(updatedClassification.getModified())).isFalse(); - // TODO - resume old behaviour after attachment query is possible. - TaskService taskService = taskanaEngine.getTaskService(); - - List tasksWithPrio99 = - List.of( - "TKI:000000000000000000000000000000000003", - "TKI:000000000000000000000000000000000004", - "TKI:000000000000000000000000000000000005", - "TKI:000000000000000000000000000000000006", - "TKI:000000000000000000000000000000000007", - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000012", - "TKI:000000000000000000000000000000000013", - "TKI:000000000000000000000000000000000014", - "TKI:000000000000000000000000000000000015", - "TKI:000000000000000000000000000000000016", - "TKI:000000000000000000000000000000000017", - "TKI:000000000000000000000000000000000018", - "TKI:000000000000000000000000000000000019", - "TKI:000000000000000000000000000000000020", - "TKI:000000000000000000000000000000000021", - "TKI:000000000000000000000000000000000022", - "TKI:000000000000000000000000000000000023", - "TKI:000000000000000000000000000000000024", - "TKI:000000000000000000000000000000000025", - "TKI:000000000000000000000000000000000026", - "TKI:000000000000000000000000000000000027", - "TKI:000000000000000000000000000000000028", - "TKI:000000000000000000000000000000000029", - "TKI:000000000000000000000000000000000030", - "TKI:000000000000000000000000000000000031", - "TKI:000000000000000000000000000000000032", - "TKI:000000000000000000000000000000000033", - "TKI:000000000000000000000000000000000034", - "TKI:000000000000000000000000000000000035", - "TKI:000000000000000000000000000000000100", - "TKI:000000000000000000000000000000000101", - "TKI:000000000000000000000000000000000102", - "TKI:000000000000000000000000000000000103", - "TKI:200000000000000000000000000000000007", - "TKI:000000000000000000000000000000000000", - "TKI:000000000000000000000000000000000052", - "TKI:000000000000000000000000000000000053", - "TKI:000000000000000000000000000000000054", - "TKI:000000000000000000000000000000000008", - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPrio99, taskService, converter, 1, 99); - - List tasksWithPrio101 = List.of("TKI:000000000000000000000000000000000011"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPrio101, taskService, converter, 1, 101); - - updatedClassification.setPriority(7); - updateClassificationAndRunAssociatedJobs(updatedClassification); - - List tasksWithPrio7 = - List.of( - "TKI:000000000000000000000000000000000003", - "TKI:000000000000000000000000000000000004", - "TKI:000000000000000000000000000000000005", - "TKI:000000000000000000000000000000000006", - "TKI:000000000000000000000000000000000007", - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000012", - "TKI:000000000000000000000000000000000013", - "TKI:000000000000000000000000000000000014", - "TKI:000000000000000000000000000000000015", - "TKI:000000000000000000000000000000000016", - "TKI:000000000000000000000000000000000017", - "TKI:000000000000000000000000000000000018", - "TKI:000000000000000000000000000000000019", - "TKI:000000000000000000000000000000000020", - "TKI:000000000000000000000000000000000021", - "TKI:000000000000000000000000000000000022", - "TKI:000000000000000000000000000000000023", - "TKI:000000000000000000000000000000000024", - "TKI:000000000000000000000000000000000025", - "TKI:000000000000000000000000000000000026", - "TKI:000000000000000000000000000000000027", - "TKI:000000000000000000000000000000000028", - "TKI:000000000000000000000000000000000029", - "TKI:000000000000000000000000000000000030", - "TKI:000000000000000000000000000000000031", - "TKI:000000000000000000000000000000000032", - "TKI:000000000000000000000000000000000033", - "TKI:000000000000000000000000000000000034", - "TKI:000000000000000000000000000000000035", - "TKI:000000000000000000000000000000000100", - "TKI:000000000000000000000000000000000101", - "TKI:000000000000000000000000000000000102", - "TKI:000000000000000000000000000000000103", - "TKI:000000000000000000000000000000000000", - "TKI:000000000000000000000000000000000052", - "TKI:000000000000000000000000000000000053", - "TKI:000000000000000000000000000000000054", - "TKI:000000000000000000000000000000000055", - "TKI:200000000000000000000000000000000007"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPrio7, taskService, converter, 1, 7); - - List tasksWithPrio9 = List.of("TKI:000000000000000000000000000000000008"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPrio9, taskService, converter, 1, 9); - - tasksWithPrio101 = List.of("TKI:000000000000000000000000000000000011"); - - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPrio101, taskService, converter, 1, 101); - } - - @WithAccessId(user = "admin") - @Test - void testUpdateClassificationChangeServiceLevel() throws Exception { - final Instant before = Instant.now(); - Classification classification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - final Instant modifiedBefore = classification.getModified(); - - classification.setPriority(555); - classification.setServiceLevel("P12D"); - - updateClassificationAndRunAssociatedJobs(classification); - // Get and check the new value - Classification updatedClassification = - classificationService.getClassification("CLI:100000000000000000000000000000000003"); - assertThat(updatedClassification).isNotNull(); - assertThat(updatedClassification.getModified()).isAfter(modifiedBefore); - // TODO - resume old behaviour after attachment query is possible. - TaskService taskService = taskanaEngine.getTaskService(); - List tasksWithPD12 = - List.of( - "TKI:000000000000000000000000000000000003", - "TKI:000000000000000000000000000000000004", - "TKI:000000000000000000000000000000000005", - "TKI:000000000000000000000000000000000006", - "TKI:000000000000000000000000000000000007", - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000012", - "TKI:000000000000000000000000000000000013", - "TKI:000000000000000000000000000000000014", - "TKI:000000000000000000000000000000000015", - "TKI:000000000000000000000000000000000016", - "TKI:000000000000000000000000000000000017", - "TKI:000000000000000000000000000000000018", - "TKI:000000000000000000000000000000000019", - "TKI:000000000000000000000000000000000020", - "TKI:000000000000000000000000000000000021", - "TKI:000000000000000000000000000000000022", - "TKI:000000000000000000000000000000000023", - "TKI:000000000000000000000000000000000024", - "TKI:000000000000000000000000000000000025", - "TKI:000000000000000000000000000000000026", - "TKI:000000000000000000000000000000000027", - "TKI:000000000000000000000000000000000028", - "TKI:000000000000000000000000000000000029", - "TKI:000000000000000000000000000000000030", - "TKI:000000000000000000000000000000000031", - "TKI:000000000000000000000000000000000032", - "TKI:000000000000000000000000000000000033", - "TKI:000000000000000000000000000000000034", - "TKI:000000000000000000000000000000000035", - "TKI:000000000000000000000000000000000100", - "TKI:000000000000000000000000000000000101", - "TKI:000000000000000000000000000000000102", - "TKI:000000000000000000000000000000000103", - "TKI:200000000000000000000000000000000007"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPD12, taskService, converter, 12, 555); - - List tasksWithPD8 = List.of("TKI:000000000000000000000000000000000008"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPD8, taskService, converter, 8, 555); - - List tasksWithPD1 = - List.of( - "TKI:000000000000000000000000000000000000", - "TKI:000000000000000000000000000000000052", - "TKI:000000000000000000000000000000000053", - "TKI:000000000000000000000000000000000054", - "TKI:000000000000000000000000000000000055"); - validateTaskPropertiesAfterClassificationChange( - before, tasksWithPD1, taskService, converter, 1, 555); - } - - private void updateClassificationAndRunAssociatedJobs(Classification classification) - throws Exception { - classificationService.updateClassification(classification); - Thread.sleep(10); - // run the ClassificationChangedJob - JobRunner runner = new JobRunner(taskanaEngine); - // run the TaskRefreshJob that was scheduled by the ClassificationChangedJob. - runner.runJobs(); - Thread.sleep(10); // otherwise the next runJobs call intermittently doesn't find the Job created - // by the previous step (it searches with DueDate < CurrentTime) - runner.runJobs(); - } - - private void validateTaskPropertiesAfterClassificationChange( - Instant before, - List tasksUpdated, - TaskService taskService, - WorkingDaysToDaysConverter converter, - int serviceLevel, - int priority) - throws Exception { - for (String taskId : tasksUpdated) { - Task task = taskService.getTask(taskId); - - assertThat(task.getModified()) - .describedAs("Task " + task.getId() + " has not been refreshed.") - .isAfter(before); - Instant expDue = - converter.addWorkingDaysToInstant(task.getPlanned(), Duration.ofDays(serviceLevel)); - - assertThat(task.getDue()).isEqualTo(expDue); - assertThat(task.getPriority()).isEqualTo(priority); - } - } -}