Closes #2256 - Refactor SetOwnerAccTest to use test-api
This commit is contained in:
jamesrdi
Elena Mokeeva
parent
8226f8d8ba
commit
a7e569466a
|
|
@ -22,6 +22,7 @@ import pro.taskana.task.api.TaskState;
|
|||
import pro.taskana.task.api.exceptions.InvalidOwnerException;
|
||||
import pro.taskana.task.api.models.ObjectReference;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.testapi.DefaultTestEntities;
|
||||
import pro.taskana.testapi.TaskanaConfigurationModifier;
|
||||
import pro.taskana.testapi.TaskanaInject;
|
||||
import pro.taskana.testapi.TaskanaIntegrationTest;
|
||||
|
|
@ -410,6 +411,44 @@ class ClaimTaskAccTest {
|
|||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_OwnerOfReadyForReviewTaskIsSet() throws Exception {
|
||||
String anyUserName = "TestUser28";
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.owner(anyUserName)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task taskClaimed = taskService.claim(taskReadyForReview.getId());
|
||||
|
||||
assertThat(taskClaimed.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(taskClaimed.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_OwnerOfReadyTaskIsSet() throws Exception {
|
||||
String anyUserName = "TestUser28";
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.owner(anyUserName)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task taskClaimed = taskService.claim(taskReadyForReview.getId());
|
||||
|
||||
assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(taskClaimed.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WithAdditionalUserInfoEnabled implements TaskanaConfigurationModifier {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,419 @@
|
|||
package acceptance.task.claim;
|
||||
|
||||
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.defaultTestObjectReference;
|
||||
import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map.Entry;
|
||||
import org.assertj.core.api.Condition;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
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.exceptions.TaskanaException;
|
||||
import pro.taskana.task.api.TaskService;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.exceptions.InvalidTaskStateException;
|
||||
import pro.taskana.task.api.exceptions.TaskNotFoundException;
|
||||
import pro.taskana.task.api.models.ObjectReference;
|
||||
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.exceptions.NotAuthorizedOnWorkbasketException;
|
||||
import pro.taskana.workbasket.api.models.WorkbasketSummary;
|
||||
|
||||
@TaskanaIntegrationTest
|
||||
class SetOwnerAccTest {
|
||||
@TaskanaInject TaskService taskService;
|
||||
@TaskanaInject ClassificationService classificationService;
|
||||
@TaskanaInject WorkbasketService workbasketService;
|
||||
|
||||
ClassificationSummary defaultClassificationSummary;
|
||||
WorkbasketSummary defaultWorkbasketSummary;
|
||||
ObjectReference defaultObjectReference;
|
||||
|
||||
@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);
|
||||
|
||||
defaultObjectReference = defaultTestObjectReference().build();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetOwner_When_TaskIsReadyForReview() throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService);
|
||||
String anyUserName = "TestUser28";
|
||||
|
||||
Task modifiedTaskReady = setOwner(taskReadyForReview, anyUserName);
|
||||
|
||||
assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetOwner_When_TaskIsReady() throws Exception {
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService);
|
||||
String anyUserName = "TestUser27";
|
||||
|
||||
Task modifiedTaskReady = setOwner(taskReady, anyUserName);
|
||||
|
||||
assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_SetOwnerViaUpdateTaskIsNotAuthorizedOnWorkbasket()
|
||||
throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService, "admin");
|
||||
String anyUserName = "TestUser3";
|
||||
|
||||
ThrowingCallable call2 = () -> setOwner(taskReadyForReview, anyUserName);
|
||||
|
||||
NotAuthorizedOnWorkbasketException e2 =
|
||||
catchThrowableOfType(call2, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e2.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e2.getCurrentUserId()).isEqualTo("user-1-1");
|
||||
assertThat(e2.getRequiredPermissions()).containsExactly(WorkbasketPermission.READ);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_SetOwnerOfClaimedTaskFails() throws Exception {
|
||||
Task taskClaimed =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.CLAIMED)
|
||||
.owner("user-1-1")
|
||||
.buildAndStore(taskService, "admin");
|
||||
String anyUserName = "TestUser007";
|
||||
|
||||
ThrowingCallable call = () -> setOwner(taskClaimed, anyUserName);
|
||||
|
||||
InvalidTaskStateException e = catchThrowableOfType(call, InvalidTaskStateException.class);
|
||||
assertThat(e.getTaskId()).isEqualTo(taskClaimed.getId());
|
||||
assertThat(e.getTaskState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(e.getRequiredTaskStates())
|
||||
.containsExactlyInAnyOrder(TaskState.READY, TaskState.READY_FOR_REVIEW);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_SetOwnerViaSetOwnerOfTasksIsNotAuthorizedOnWorkbasket()
|
||||
throws Exception {
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
|
||||
String anyUserName = "TestUser3";
|
||||
taskService.setOwnerOfTasks(anyUserName, List.of(taskReady.getId()));
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks(anyUserName, List.of(taskReady.getId()));
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorForId(taskReady.getId()))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetMOwnerOfMultipleTasks_When_TasksAreReadyAndReadyForReview() throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
List<String> taskIds = List.of(taskReadyForReview.getId(), taskReady.getId());
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks("someUser", taskIds);
|
||||
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetOwnerOfTasks_When_TasksAreDuplicated() throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
taskReady.getId(),
|
||||
taskReadyForReview.getId(),
|
||||
taskReady.getId(),
|
||||
taskReadyForReview.getId());
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks("someUser", taskIds);
|
||||
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetOwnerOfTasks_When_TasksAreDuplicatedAndTaskNotExisting() throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
taskReady.getId(),
|
||||
"TKI:000000000000000000000000000047110059",
|
||||
taskReadyForReview.getId(),
|
||||
taskReady.getId());
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks("someUser", taskIds);
|
||||
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap()).hasSize(1);
|
||||
assertThat(results.getErrorForId("TKI:000000000000000000000000000047110059"))
|
||||
.isInstanceOf(TaskNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void should_ReturnExceptions_When_SettingOwnerOfMultipleTasksWhileNotAuthorized()
|
||||
throws Exception {
|
||||
Task taskReadyForReview =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task taskReady =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
List<String> taskIds =
|
||||
List.of(taskReady.getId(), taskReadyForReview.getId(), taskReady.getId());
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks("someUser", taskIds);
|
||||
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap()).hasSize(2);
|
||||
assertThat(results.getErrorForId(taskReady.getId()))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(results.getErrorForId(taskReadyForReview.getId()))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void should_SetOwnerOfMultipleTask_When_TaskListIsEmpty() {
|
||||
List<String> taskIds = new ArrayList<>();
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks("someUser", taskIds);
|
||||
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_SetOwnerOfMultipleTasksAndThrowVariousExceptions() throws Exception {
|
||||
WorkbasketSummary defaultWorkbasketSummary2 =
|
||||
defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService, "admin");
|
||||
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
|
||||
.workbasketId(defaultWorkbasketSummary2.getId())
|
||||
.accessId("user-1-1")
|
||||
.permission(WorkbasketPermission.OPEN)
|
||||
.permission(WorkbasketPermission.READ)
|
||||
.permission(WorkbasketPermission.APPEND)
|
||||
.buildAndStore(workbasketService, "admin");
|
||||
Task task1 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary2)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task2 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary2)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.COMPLETED)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task3 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.COMPLETED)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task4 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks(
|
||||
"theWorkaholic", List.of(task1.getId(), task2.getId(), task3.getId(), task4.getId()));
|
||||
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
|
||||
Condition<Object> invalidTaskStateException =
|
||||
new Condition<>(
|
||||
c -> c.getClass() == InvalidTaskStateException.class, "InvalidStateException");
|
||||
Condition<Object> mismatchedWorkbasketPermissionException =
|
||||
new Condition<>(
|
||||
c -> c.getClass() == NotAuthorizedOnWorkbasketException.class,
|
||||
"MismatchedWorkbasketPermissionException");
|
||||
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(3)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfTypes(
|
||||
InvalidTaskStateException.class, NotAuthorizedOnWorkbasketException.class)
|
||||
.areExactly(1, invalidTaskStateException)
|
||||
.areExactly(2, mismatchedWorkbasketPermissionException);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_SetOwnerOfMultipleTasksAndThrowVariousExceptionsAsAdmin() throws Exception {
|
||||
WorkbasketSummary defaultWorkbasketSummary2 =
|
||||
defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService, "admin");
|
||||
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
|
||||
.workbasketId(defaultWorkbasketSummary2.getId())
|
||||
.accessId("user-1-1")
|
||||
.permission(WorkbasketPermission.OPEN)
|
||||
.permission(WorkbasketPermission.READ)
|
||||
.permission(WorkbasketPermission.APPEND)
|
||||
.buildAndStore(workbasketService, "admin");
|
||||
Task task1 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary2)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task2 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary2)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.COMPLETED)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task3 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.COMPLETED)
|
||||
.buildAndStore(taskService, "admin");
|
||||
Task task4 =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build())
|
||||
.state(TaskState.READY)
|
||||
.buildAndStore(taskService, "admin");
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks(
|
||||
"theWorkaholic", List.of(task1.getId(), task2.getId(), task3.getId(), task4.getId()));
|
||||
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(2)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfType(InvalidTaskStateException.class);
|
||||
}
|
||||
|
||||
private Task setOwner(Task task, String anyUserName) throws Exception {
|
||||
task.setOwner(anyUserName);
|
||||
task = taskService.updateTask(task);
|
||||
return task;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,240 +0,0 @@
|
|||
package acceptance.task.claim;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import acceptance.TaskanaEngineProxy;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.stream.Collectors;
|
||||
import org.assertj.core.api.Condition;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import pro.taskana.common.api.BulkOperationResults;
|
||||
import pro.taskana.common.api.exceptions.TaskanaException;
|
||||
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.TaskState;
|
||||
import pro.taskana.task.api.exceptions.InvalidTaskStateException;
|
||||
import pro.taskana.task.api.exceptions.TaskNotFoundException;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.api.models.TaskSummary;
|
||||
import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
|
||||
|
||||
/** Acceptance test for all "set owner" scenarios. */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class SetOwnerAccTest extends AbstractAccTest {
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerOfReadyTaskAndSubsequentClaimSucceeds() throws Exception {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String taskReadyId = "TKI:000000000000000000000000000000000025";
|
||||
Task taskReady = taskService.getTask(taskReadyId);
|
||||
assertThat(taskReady.getState()).isEqualTo(TaskState.READY);
|
||||
String anyUserName = "TestUser27";
|
||||
assertThat(taskReady.getOwner()).isNotEqualTo(anyUserName);
|
||||
Task modifiedTaskReady = setOwner(taskReadyId, anyUserName);
|
||||
|
||||
assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
|
||||
Task taskClaimed = taskService.claim(taskReadyId);
|
||||
assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(taskClaimed.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerOfReadyForReviewTaskAndSubsequentClaimSucceeds() throws Exception {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String taskReadyForReviewId = "TKI:100000000000000000000000000000000025";
|
||||
Task taskReady = taskService.getTask(taskReadyForReviewId);
|
||||
assertThat(taskReady.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
String anyUserName = "TestUser28";
|
||||
assertThat(taskReady.getOwner()).isNotEqualTo(anyUserName);
|
||||
Task modifiedTaskReady = setOwner(taskReadyForReviewId, anyUserName);
|
||||
|
||||
assertThat(modifiedTaskReady.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(modifiedTaskReady.getOwner()).isEqualTo(anyUserName);
|
||||
Task taskClaimed = taskService.claim(taskReadyForReviewId);
|
||||
assertThat(taskClaimed.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(taskClaimed.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerViaUpdateTaskNotAuthorized() {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String taskReadyId = "TKI:000000000000000000000000000000000024";
|
||||
String anyUserName = "TestUser3";
|
||||
|
||||
assertThatThrownBy(() -> taskService.getTask(taskReadyId))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
assertThatThrownBy(() -> setOwner(taskReadyId, anyUserName))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerOfClaimedTaskFails() throws Exception {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String taskClaimedId = "TKI:000000000000000000000000000000000026";
|
||||
String anyUserName = "TestUser007";
|
||||
Task taskClaimed = taskService.getTask(taskClaimedId);
|
||||
assertThat(taskClaimed.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(taskClaimed.getOwner()).isEqualTo("user-1-1");
|
||||
assertThatThrownBy(() -> setOwner(taskClaimedId, anyUserName))
|
||||
.isInstanceOf(InvalidTaskStateException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerNotAuthorized() {
|
||||
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
String taskReadyId = "TKI:000000000000000000000000000000000024";
|
||||
String anyUserName = "TestUser3";
|
||||
|
||||
assertThatThrownBy(() -> taskService.getTask(taskReadyId))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.setOwnerOfTasks(anyUserName, List.of(taskReadyId));
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorForId(taskReadyId))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerOfReadyAndReadyForReviewTasks() {
|
||||
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000033", "TKI:500000000000000000000000000000000028");
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void testSetOwnerOfTasksWithDuplicatesSucceeds() {
|
||||
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000058",
|
||||
"TKI:000000000000000000000000000000000059",
|
||||
"TKI:000000000000000000000000000000000058",
|
||||
"TKI:000000000000000000000000000000000060");
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void testSetOwnerOfTasksWithDuplicatesAndNotExistingSucceeds() {
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000058",
|
||||
"TKI:000000000000000000000000000047110059",
|
||||
"TKI:000000000000000000000000000000000059",
|
||||
"TKI:000000000000000000000000000000000058",
|
||||
"TKI:000000000000000000000000000000000060");
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap()).hasSize(1);
|
||||
assertThat(results.getErrorForId("TKI:000000000000000000000000000047110059"))
|
||||
.isInstanceOf(TaskNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void testSetOwnerOfTasksWithNoQualifyingTasks() {
|
||||
|
||||
List<String> taskIds =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000008",
|
||||
"TKI:000000000000000000000000000000000009",
|
||||
"TKI:000000000000000000000000000000000008",
|
||||
"TKI:000000000000000000000000000000000010");
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap()).hasSize(3);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-b-2")
|
||||
@Test
|
||||
void testSetOwnerWithEmptyList() {
|
||||
List<String> taskIds = new ArrayList<>();
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void testSetOwnerWithAllTasksAndVariousExceptions() throws Exception {
|
||||
resetDb(false);
|
||||
List<TaskSummary> allTaskSummaries =
|
||||
new TaskanaEngineProxy(taskanaEngine)
|
||||
.getEngine()
|
||||
.getEngine()
|
||||
.runAsAdmin(() -> taskanaEngine.getTaskService().createTaskQuery().list());
|
||||
List<String> allTaskIds =
|
||||
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
|
||||
assertThat(allTaskSummaries).hasSize(99);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
|
||||
Condition<Object> invalidTaskStateException =
|
||||
new Condition<>(
|
||||
c -> c.getClass() == InvalidTaskStateException.class, "InvalidStateException");
|
||||
Condition<Object> mismatchedWorkbasketPermissionException =
|
||||
new Condition<>(
|
||||
c -> c.getClass() == NotAuthorizedOnWorkbasketException.class,
|
||||
"MismatchedWorkbasketPermissionException");
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(95)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfTypes(
|
||||
InvalidTaskStateException.class, NotAuthorizedOnWorkbasketException.class)
|
||||
.areExactly(35, invalidTaskStateException)
|
||||
.areExactly(60, mismatchedWorkbasketPermissionException);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin() throws Exception {
|
||||
resetDb(false);
|
||||
List<TaskSummary> allTaskSummaries = taskanaEngine.getTaskService().createTaskQuery().list();
|
||||
List<String> allTaskIds =
|
||||
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
|
||||
assertThat(allTaskSummaries).hasSize(99);
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap())
|
||||
.hasSize(49)
|
||||
.extractingFromEntries(Entry::getValue)
|
||||
.hasOnlyElementsOfType(InvalidTaskStateException.class);
|
||||
}
|
||||
|
||||
private Task setOwner(String taskReadyId, String anyUserName) throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask(taskReadyId);
|
||||
task.setOwner(anyUserName);
|
||||
task = taskService.updateTask(task);
|
||||
return task;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue