Closes #2202 - ClaimTaskAccTest refactored to use test-api
This commit is contained in:
jamesrdi
Elena Mokeeva
parent
d6992500db
commit
d7130ee50f
|
|
@ -0,0 +1,397 @@
|
|||
package acceptance.task.claim;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatCode;
|
||||
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.time.Instant;
|
||||
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.task.api.TaskService;
|
||||
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.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 ClaimTaskAccTest {
|
||||
@TaskanaInject TaskService taskService;
|
||||
@TaskanaInject ClassificationService classificationService;
|
||||
@TaskanaInject WorkbasketService workbasketService;
|
||||
|
||||
ClassificationSummary defaultClassificationSummary;
|
||||
WorkbasketSummary defaultWorkbasketSummary;
|
||||
ObjectReference defaultObjectReference;
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@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_ClaimTask_When_TaskIsReady() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task claimedTask = taskService.claim(task.getId());
|
||||
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_TaskIsReadyForReview() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task claimedTask = taskService.claim(task.getId());
|
||||
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
|
||||
InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
|
||||
assertThat(e.getTaskId()).isEqualTo(task.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskIsAlreadyInReviewByAnotherUser() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
|
||||
InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
|
||||
assertThat(e.getTaskId()).isEqualTo(task.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_AlreadyClaimedByCaller() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-2")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_AlreadyInReviewByCaller() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-2")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task claimedTask = taskService.forceClaim(task.getId());
|
||||
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task claimedTask = taskService.forceClaim(task.getId());
|
||||
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReady()
|
||||
throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.READY)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService, "user-1-2");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
|
||||
NotAuthorizedOnWorkbasketException e =
|
||||
catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-taskrouter");
|
||||
assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e.getRequiredPermissions()).containsExactlyInAnyOrder(WorkbasketPermission.READ);
|
||||
|
||||
;
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReadyForReview()
|
||||
throws Exception {
|
||||
Task task =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.READY_FOR_REVIEW)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService, "user-1-2");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
|
||||
NotAuthorizedOnWorkbasketException e =
|
||||
catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-taskrouter");
|
||||
assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e.getRequiredPermissions()).containsExactlyInAnyOrder(WorkbasketPermission.READ);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CancelClaimTask_When_TaskIsClaimed() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-2")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task unclaimedTask = taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CancelClaimTask_When_TaskIsInReview() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-2")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task unclaimedTask = taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskClaimedByAnotherUser() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
|
||||
assertThat(e.getTaskId()).isEqualTo(claimedTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskInReviewByAnotherUser() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-2")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("taskadmin");
|
||||
assertThat(e.getTaskId()).isEqualTo(claimedTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCancelClaim_When_TaskClaimedByAnotherUser() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.CLAIMED)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task unclaimedTask = taskService.forceCancelClaim(claimedTask.getId());
|
||||
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCancelClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
Task claimedTask =
|
||||
TaskBuilder.newTask()
|
||||
.state(TaskState.IN_REVIEW)
|
||||
.claimed(Instant.now())
|
||||
.owner("user-1-1")
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.workbasketSummary(defaultWorkbasketSummary)
|
||||
.primaryObjRef(defaultObjectReference)
|
||||
.buildAndStore(taskService);
|
||||
|
||||
Task unclaimedTask = taskService.forceCancelClaim(claimedTask.getId());
|
||||
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
}
|
||||
|
|
@ -1,225 +0,0 @@
|
|||
package acceptance.task.claim;
|
||||
|
||||
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 org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
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.InvalidOwnerException;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
|
||||
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class ClaimTaskAccTest extends AbstractAccTest {
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_TaskIsReady() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000025");
|
||||
|
||||
taskService.claim(task.getId());
|
||||
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000025");
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_TaskIsReadyForReview() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:100000000000000000000000000000000025");
|
||||
|
||||
taskService.claim(task.getId());
|
||||
|
||||
Task claimedTask = taskService.getTask("TKI:100000000000000000000000000000000025");
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskIsAlreadyClaimed() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000026");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskIsAlreadyInReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:600000000000000000000000000000000028");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_AlreadyClaimedByCaller() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
|
||||
|
||||
assertThat(task.getState()).isSameAs(TaskState.CLAIMED);
|
||||
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ClaimTask_When_AlreadyInReviewByCaller() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
assertThat(task.getState()).isSameAs(TaskState.IN_REVIEW);
|
||||
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000028");
|
||||
|
||||
ThrowingCallable call = () -> taskService.claim(task.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:200000000000000000000000000000000028");
|
||||
|
||||
Task claimedTask = taskService.forceClaim(task.getId());
|
||||
assertThat(claimedTask).isNotNull();
|
||||
assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
|
||||
assertThat(claimedTask.getClaimed()).isNotNull();
|
||||
assertThat(claimedTask.getModified())
|
||||
.isNotEqualTo(claimedTask.getCreated())
|
||||
.isEqualTo(claimedTask.getClaimed());
|
||||
assertThat(claimedTask.isRead()).isTrue();
|
||||
assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReady() {
|
||||
assertThatThrownBy(() -> taskService.claim("TKI:000000000000000000000000000000000000"))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReadyForReview() {
|
||||
assertThatThrownBy(() -> taskService.claim("TKI:500000000000000000000000000000000028"))
|
||||
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CancelClaimTask_When_TaskIsClaimed() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
|
||||
|
||||
taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CancelClaimTask_When_TaskIsInReview() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
taskService.cancelClaim(claimedTask.getId());
|
||||
|
||||
Task unclaimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
|
||||
// Claim Task, so it can be used in a different test
|
||||
taskService.claim(unclaimedTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
|
||||
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@Test
|
||||
void should_ThrowException_When_CancelClaimingATaskInReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
|
||||
|
||||
ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCancelClaim_When_TaskClaimedByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
|
||||
|
||||
taskService.forceCancelClaim(claimedTask.getId());
|
||||
|
||||
Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ForceCancelClaimTask_When_InReviewByAnotherUser() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:100000000000000000000000000000000028");
|
||||
|
||||
Task unclaimedTask = taskService.forceCancelClaim(task.getId());
|
||||
assertThat(unclaimedTask).isNotNull();
|
||||
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
|
||||
assertThat(unclaimedTask.getClaimed()).isNull();
|
||||
assertThat(unclaimedTask.isRead()).isTrue();
|
||||
assertThat(unclaimedTask.getOwner()).isNull();
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue