nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-1925: clean up claimTaskAccTest

This commit is contained in:
ryzheboka 2022-09-14 09:44:23 +02:00 committed by Elena Mokeeva
parent fda6a090c0
commit d77c4846ed
2 changed files with 55 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
lib/taskana-core-test/src/test/java/acceptance/task/complete/CompleteTaskAccTest.java
View File

@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.catchThrowableOfType;
import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification;
import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket;
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
@ -71,7 +72,7 @@ class CompleteTaskAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_CompleteClaimedTask() throws Exception {
void should_CompleteTask_When_TaskIsClaimed() throws Exception {
Task claimedTask = createTaskClaimedByUser_1_1().buildAndStore(taskService);
Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
@ -80,6 +81,17 @@ class CompleteTaskAccTest {
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void should_CompleteTask_When_TaskIsInReview() throws Exception {
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
Task claimedTask = createTaskInReviewByUser_1_1().buildAndStore(taskService);
Task completedTask = taskService.completeTask(claimedTask.getId());
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "admin")
@Test
void should_CompleteClaimedTaskByAnotherUser_When_UserIsAdmin() throws Exception {
@ -117,7 +129,7 @@ class CompleteTaskAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ForceCompleteClaimedTask_When_TaskCallerIsNotTheOwner() throws Exception {
void should_ForceCompleteTask_When_ClaimedByAnotherUser() throws Exception {
Task task = createTaskClaimedByUser_1_1().owner("other").buildAndStore(taskService);
Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
@ -126,6 +138,17 @@ class CompleteTaskAccTest {
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ForceCompleteTask_When_InReviewByAnotherUser() throws Exception {
Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
Task claimedTask = createTaskInReviewByUser_1_1().owner("other").buildAndStore(taskService);
Task completedTask = taskService.forceCompleteTask(claimedTask.getId());
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ForceCompleteTask_When_TaskIsNotClaimed() throws Exception {
@ -137,6 +160,18 @@ class CompleteTaskAccTest {
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ForceCompleteTask_When_TaskIsReadyForReview() throws Exception {
Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
Task readyForReviewTask =
createDefaultTask().state(TaskState.READY_FOR_REVIEW).buildAndStore(taskService);
Task completedTask = taskService.forceCompleteTask(readyForReviewTask.getId());
assertTaskIsComplete(before, completedTask);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_CompletingNonExistingTask() {
@ -191,6 +226,16 @@ class CompleteTaskAccTest {
assertThat(e.getTaskId()).isEqualTo(task.getId());
}
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_CompletingTaskInReviewByAnotherUser() throws Exception {
Task inReviewTask = createTaskInReviewByUser_1_1().owner("other").buildAndStore(taskService);
ThrowingCallable call = () -> taskService.completeTask(inReviewTask.getId());
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ClaimTask_When_UsingDefaultFlag() throws Exception {
@ -635,6 +680,14 @@ class CompleteTaskAccTest {
.claimed(Instant.now());
}
private TaskBuilder createTaskInReviewByUser_1_1() {
return createDefaultTask()
.owner("user-1-1")
.created(Instant.parse("2018-01-29T15:55:00Z"))
.state(TaskState.IN_REVIEW)
.claimed(Instant.now());
}
private TaskBuilder createDefaultTask() {
return TaskBuilder.newTask()
.classificationSummary(defaultClassificationSummary)

151
lib/taskana-core/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java
View File

@ -5,22 +5,16 @@ 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.extension.ExtendWith;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
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.InvalidOwnerException;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.models.Task;
@ExtendWith(JaasExtension.class)
@ -229,149 +223,4 @@ class ClaimTaskAccTest extends AbstractAccTest {
assertThat(unclaimedTask.isRead()).isTrue();
assertThat(unclaimedTask.getOwner()).isNull();
}
@WithAccessId(user = "user-1-2")
@Test
void should_CompleteTask_When_TaskIsClaimed() throws Exception {
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000032");
taskService.completeTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000032");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.getCompleted().isAfter(before)).isTrue();
assertThat(completedTask.getModified().isAfter(before)).isTrue();
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "user-1-2")
@Test
void should_CompleteTask_When_TaskIsInReview() throws Exception {
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:400000000000000000000000000000000028");
taskService.completeTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:400000000000000000000000000000000028");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.getCompleted().isAfter(before)).isTrue();
assertThat(completedTask.getModified().isAfter(before)).isTrue();
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "user-1-2")
@Test
void should_CompleteTaskUsingForceComplete_When_TaskIsUnclaimed() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000033");
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000033");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "user-1-2")
@Test
void should_CompleteTaskUsingForceComplete_When_TaskIsReadyForReview() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:500000000000000000000000000000000028");
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:500000000000000000000000000000000028");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "user-1-2")
@Test
void should_ThrowException_When_CompletingTaskClaimedByAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000034");
ThrowingCallable call = () -> taskService.completeTask(claimedTask.getId());
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void should_ThrowException_When_CompletingTaskInReviewByAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:700000000000000000000000000000000028");
ThrowingCallable call = () -> taskService.completeTask(claimedTask.getId());
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void should_ForceCompleteTask_When_ClaimedByAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000035");
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000035");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "user-1-2")
@Test
void should_ForceCompleteTask_When_InReviewByAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:300000000000000000000000000000000028");
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:300000000000000000000000000000000028");
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user-1-2");
}
@WithAccessId(user = "admin")
@Test
void should_ReturnExceptions_WhenBulkDeletingInvalidTasks() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
String id1 = "TKI:000000000000000000000000000000000102"; // claimed by someone
String id2 = "TKI:100000000000000000000000000000000028"; // in review by someone
List<String> taskIdList = List.of(id1, id2);
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getFailedIds()).containsExactlyInAnyOrder(id1, id2);
assertThat(results.getErrorForId(id1)).isInstanceOf(InvalidStateException.class);
assertThat(results.getErrorForId(id2)).isInstanceOf(InvalidStateException.class);
}
}