diff --git a/lib/taskana-core-test/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java b/lib/taskana-core-test/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java new file mode 100644 index 000000000..c951a85e1 --- /dev/null +++ b/lib/taskana-core-test/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java @@ -0,0 +1,160 @@ +package acceptance.task.complete; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchThrowableOfType; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket; + +import java.util.List; +import java.util.stream.Stream; +import org.assertj.core.api.ThrowableAssert.ThrowingCallable; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.TestFactory; +import org.junit.jupiter.api.TestTemplate; +import org.junit.jupiter.api.function.ThrowingConsumer; +import pro.taskana.classification.api.ClassificationService; +import pro.taskana.classification.api.models.ClassificationSummary; +import pro.taskana.common.api.TaskanaRole; +import pro.taskana.common.api.exceptions.NotAuthorizedException; +import pro.taskana.common.api.security.CurrentUserContext; +import pro.taskana.common.internal.util.Triplet; +import pro.taskana.task.api.TaskService; +import pro.taskana.task.api.TaskState; +import pro.taskana.task.api.exceptions.InvalidTaskStateException; +import pro.taskana.task.api.models.Task; +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.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; + +@TaskanaIntegrationTest +class TerminateTaskAccTest { + @TaskanaInject TaskService taskService; + @TaskanaInject ClassificationService classificationService; + @TaskanaInject WorkbasketService workbasketService; + @TaskanaInject CurrentUserContext currentUserContext; + + ClassificationSummary defaultClassificationSummary; + WorkbasketSummary defaultWorkbasketSummary; + + @WithAccessId(user = "admin") + @BeforeAll + void setup() throws Exception { + defaultClassificationSummary = + defaultTestClassification().buildAndStoreAsSummary(classificationService); + defaultWorkbasketSummary = defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService); + + WorkbasketAccessItemBuilder.newWorkbasketAccessItem() + .workbasketId(defaultWorkbasketSummary.getId()) + .accessId("user-1-2") + .permission(WorkbasketPermission.OPEN) + .permission(WorkbasketPermission.READ) + .permission(WorkbasketPermission.APPEND) + .buildAndStore(workbasketService); + } + + @WithAccessId(user = "admin") + @WithAccessId(user = "taskadmin") + @TestTemplate + void should_TerminateTask_When_TaskStateIsReady() throws Exception { + Task task = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.READY) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService); + + Task readTask = taskService.terminateTask(task.getId()); + + assertThat(readTask.getState()).isEqualTo(TaskState.TERMINATED); + } + + @WithAccessId(user = "admin") + @WithAccessId(user = "taskadmin") + @TestTemplate + void should_TerminateTask_When_TaskStateIsClaimed() throws Exception { + Task task = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.CLAIMED) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService); + + Task terminatedTask = taskService.terminateTask(task.getId()); + assertThat(terminatedTask.getState()).isEqualTo(TaskState.TERMINATED); + } + + @WithAccessId(user = "user-1-2") + @WithAccessId(user = "user-taskrouter") + @TestTemplate + void should_ThrowException_When_UserIsNotInAdministrativeRole() throws Exception { + Task task = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.READY) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService, "admin"); + + ThrowingCallable call = () -> taskService.terminateTask(task.getId()); + + NotAuthorizedException e = catchThrowableOfType(call, NotAuthorizedException.class); + assertThat(e.getCurrentUserId()).isEqualTo(currentUserContext.getUserid()); + assertThat(e.getRoles()).containsExactlyInAnyOrder(TaskanaRole.ADMIN, TaskanaRole.TASK_ADMIN); + } + + @WithAccessId(user = "taskadmin") + @TestFactory + Stream should_ThrowException_When_TerminateTaskInEndState() throws Exception { + Task taskCancelled = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.CANCELLED) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService); + Task taskTerminated = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.TERMINATED) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService); + Task taskCompleted = + TaskBuilder.newTask() + .classificationSummary(defaultClassificationSummary) + .workbasketSummary(defaultWorkbasketSummary) + .state(TaskState.COMPLETED) + .primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build()) + .buildAndStore(taskService); + List> testValues = + List.of( + Triplet.of("When Task State is Cancelled", taskCancelled, TaskState.CANCELLED), + Triplet.of("When Task State is Terminated", taskTerminated, TaskState.TERMINATED), + Triplet.of("When Task State is Completed", taskCompleted, TaskState.COMPLETED)); + ThrowingConsumer> test = + t -> { + ThrowingCallable call = () -> taskService.terminateTask(t.getMiddle().getId()); + + InvalidTaskStateException e = catchThrowableOfType(call, InvalidTaskStateException.class); + assertThat(e.getRequiredTaskStates()) + .containsExactlyInAnyOrder( + TaskState.READY, + TaskState.IN_REVIEW, + TaskState.CLAIMED, + TaskState.READY_FOR_REVIEW); + assertThat(e.getTaskState()).isEqualTo(t.getRight()); + assertThat(e.getTaskId()).isEqualTo(t.getMiddle().getId()); + }; + + return DynamicTest.stream(testValues.iterator(), Triplet::getLeft, test); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java deleted file mode 100644 index 068dc414f..000000000 --- a/lib/taskana-core/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java +++ /dev/null @@ -1,109 +0,0 @@ -package acceptance.task.complete; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; - -import acceptance.AbstractAccTest; -import java.util.List; -import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestTemplate; -import org.junit.jupiter.api.extension.ExtendWith; -import pro.taskana.common.api.exceptions.NotAuthorizedException; -import pro.taskana.common.test.security.JaasExtension; -import pro.taskana.common.test.security.WithAccessId; -import pro.taskana.task.api.TaskState; -import pro.taskana.task.api.exceptions.InvalidTaskStateException; -import pro.taskana.task.api.models.TaskSummary; - -/** Acceptance tests for "terminate task" scenarios. */ -@ExtendWith(JaasExtension.class) -class TerminateTaskAccTest extends AbstractAccTest { - - @BeforeEach - void setupIndividualTest() throws Exception { - resetDb(false); - } - - @WithAccessId(user = "user-1-2") - @Test - void should_ReturnAllTerminatedTasks_When_QueryTerminatedState() { - List taskSummaries = - taskService.createTaskQuery().stateIn(TaskState.TERMINATED).list(); - assertThat(taskSummaries).hasSize(5); - } - - @WithAccessId(user = "admin") - @WithAccessId(user = "taskadmin") - @TestTemplate - void should_TerminateTask_When_TaskStateIsReady() throws Exception { - List taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list(); - assertThat(taskSummaries).hasSize(48); - taskService.terminateTask(taskSummaries.get(0).getId()); - long numTasks = taskService.createTaskQuery().stateIn(TaskState.READY).count(); - assertThat(numTasks).isEqualTo(47); - numTasks = taskService.createTaskQuery().stateIn(TaskState.TERMINATED).count(); - assertThat(numTasks).isEqualTo(6); - } - - @WithAccessId(user = "admin") - @WithAccessId(user = "taskadmin") - @TestTemplate - void should_TerminateTask_When_TaskStateIsClaimed() throws Exception { - List taskSummaries = - taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list(); - assertThat(taskSummaries).hasSize(21); - - long numTasksTerminated = taskService.createTaskQuery().stateIn(TaskState.TERMINATED).count(); - assertThat(numTasksTerminated).isEqualTo(5); - - taskService.terminateTask(taskSummaries.get(0).getId()); - long numTasksClaimed = taskService.createTaskQuery().stateIn(TaskState.CLAIMED).count(); - assertThat(numTasksClaimed).isEqualTo(20); - numTasksTerminated = taskService.createTaskQuery().stateIn(TaskState.TERMINATED).count(); - assertThat(numTasksTerminated).isEqualTo(6); - } - - @WithAccessId(user = "taskadmin") - @Test - void should_ThrowException_When_TerminateTaskWithTaskStateCompleted() { - List taskSummaries = - taskService.createTaskQuery().stateIn(TaskState.COMPLETED).list(); - assertThat(taskSummaries).hasSize(10); - ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId()); - - assertThatThrownBy(taskanaCall).isInstanceOf(InvalidTaskStateException.class); - } - - @WithAccessId(user = "user-1-2") - @WithAccessId(user = "user-taskrouter") - @TestTemplate - void should_ThrowException_When_UserIsNotInAdministrativeRole() { - ThrowingCallable taskanaCall = - () -> taskService.terminateTask("TKI:000000000000000000000000000000000000"); - - assertThatThrownBy(taskanaCall).isInstanceOf(NotAuthorizedException.class); - } - - @WithAccessId(user = "taskadmin") - @Test - void should_ThrowException_When_TerminateTaskWithTaskStateTerminated() { - List taskSummaries = - taskService.createTaskQuery().stateIn(TaskState.TERMINATED).list(); - assertThat(taskSummaries).hasSize(5); - ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId()); - - assertThatThrownBy(taskanaCall).isInstanceOf(InvalidTaskStateException.class); - } - - @WithAccessId(user = "taskadmin") - @Test - void should_ThrowException_When_TerminateTaskWithTaskStateCancelled() { - List taskSummaries = - taskService.createTaskQuery().stateIn(TaskState.CANCELLED).list(); - assertThat(taskSummaries).hasSize(5); - ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId()); - assertThatThrownBy(taskanaCall).isInstanceOf(InvalidTaskStateException.class); - } -}