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

TSK-1916: test history when requesting changes

This commit is contained in:
ryzheboka 2022-08-06 16:39:50 +02:00 committed by Elena Mokeeva
parent cc32b10d82
commit d83678ac54
11 changed files with 122 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common/taskana-common-data/src/main/resources/sql/test-data/task.sql
View File

@ -4,6 +4,7 @@ INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000001', 'ETI:0000000
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000002', 'ETI:000000000000000000000000000000000002', '2018-01-29 15:55:02', '2018-01-30 15:55:00', null , '2018-01-30 15:55:02', null , '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Task02' , 'creator_user_id' , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'MANUAL' , 'T2000' , 'CLI:100000000000000000000000000000000016', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000066', 'ETI:000000000000000000000000000000000066', '2018-01-29 15:55:02', '2018-01-29 15:55:00', null , '2018-01-30 15:55:02', null , '2018-01-29 15:55:00', '2018-01-29 15:55:00', 'Task03' , 'creator_user_id' , 'Lorem ipsum was n Quatsch t. Aber stimmt.', 'Some custom Note' , 2 , -1 , 'CLAIMED' , 'MANUAL' , 'T2001' , 'CLI:100000000000000000000000000000000024', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'MyCompany1', 'MySystem1', 'MyInstance1' , 'MyType1', 'MyValue1' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:100000000000000000000000000000000066', 'ETI:100000000000000000000000000000000066', '2012-01-29 15:55:02', '2012-01-29 15:55:00', null , '2012-01-30 15:55:02', null , '2012-01-29 15:55:00', '2012-01-29 15:55:00', 'Task003' , 'creator_user_id' , 'was n Quatsch t. Aber stimmt.' , 'Some other custom Note' , 67 , -1 , 'IN_REVIEW' , 'MANUAL' , 'T2001' , 'CLI:100000000000000000000000000000000024', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'ACompany1' , 'ASystem1' , 'AnInstance1' , 'AType1' , 'AValue1' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:200000000000000000000000000000000066', 'ETI:200000000000000000000000000000000066', '2012-01-29 15:55:02', '2012-01-29 15:55:00', null , '2012-01-30 15:55:02', null , '2012-01-29 15:55:00', '2012-01-29 15:55:00', 'Task003' , 'creator_user_id' , 'was n Quatsch t. Aber stimmt.' , 'Some other custom Note' , 67 , -1 , 'CLAIMED' , 'MANUAL' , 'T2001' , 'CLI:100000000000000000000000000000000024', 'WBI:100000000000000000000000000000000006' , 'USER-1-1' , 'DOMAIN_A', 'BPI21' , 'PBPI21' , 'user-1-1' , 'ACompany1' , 'ASystem1' , 'AnInstance1' , 'AType1' , 'AValue1' , true , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000003', 'ETI:000000000000000000000000000000000003', '2018-01-29 15:55:03', null , null , '2018-01-29 15:55:03', null , '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000001' , 'GPK_KSC' , 'DOMAIN_A', 'PI_0000000000003' , 'DOC_0000000000000000003' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , 'efg' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000004', 'ETI:000000000000000000000000000000000004', '2018-01-29 15:55:04', null , null , '2018-01-29 15:55:04', null , '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000001' , 'GPK_KSC' , 'DOMAIN_A', 'PI_0000000000004' , 'DOC_0000000000000000004' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , '' , 'ade' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );
INSERT INTO TASK VALUES('TKI:000000000000000000000000000000000005', 'ETI:000000000000000000000000000000000005', '2018-01-29 15:55:05', null , null , '2018-01-29 15:55:05', null , '2018-01-29 15:55:00', '2018-01-30 15:55:00', 'Widerruf' , 'creator_user_id' , 'Widerruf' , null , 2 , -1 , 'READY' , 'EXTERN' , 'L1050' , 'CLI:100000000000000000000000000000000003', 'WBI:100000000000000000000000000000000001' , 'GPK_KSC' , 'DOMAIN_A', 'PI_0000000000005' , 'DOC_0000000000000000005' , null , '00' , 'PASystem' , '00' , 'VNR' , '11223344' , false , false , null , 'NONE' , null , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , '' , 'abc' , '' , '' , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 );

2
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskRequestChangesAccTest.java
View File

@ -29,7 +29,7 @@ class CreateHistoryEventOnTaskRequestChangesAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_CreateClaimedHistoryEvent_When_TaskIsClaimed() throws Exception {
void should_CreateChangesRequestedHistoryEvent_When_ChangesAreRequested() throws Exception {
final String taskId = "TKI:100000000000000000000000000000000066";
final Instant oldModified = taskService.getTask(taskId).getModified();

80
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskRequestReviewAccTest.java Normal file
View File

@ -0,0 +1,80 @@
package acceptance.events.task;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.List;
import org.json.JSONArray;
import org.json.JSONObject;
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.simplehistory.impl.SimpleHistoryServiceImpl;
import pro.taskana.simplehistory.impl.TaskHistoryQueryImpl;
import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Task;
@ExtendWith(JaasExtension.class)
class CreateHistoryEventOnTaskRequestReviewAccTest extends AbstractAccTest {
private final TaskService taskService = taskanaEngine.getTaskService();
private final SimpleHistoryServiceImpl historyService = getHistoryService();
@WithAccessId(user = "user-1-1")
@Test
void should_CreateRequestReviewHistoryEvent_When_ReviewIsRequested() throws Exception {
final String taskId = "TKI:200000000000000000000000000000000066";
final Instant oldModified = taskService.getTask(taskId).getModified();
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
List<TaskHistoryEvent> events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
assertThat(events).isEmpty();
assertThat(taskService.getTask(taskId).getState()).isEqualTo(TaskState.CLAIMED);
Task task = taskService.requestReview(taskId);
assertThat(task.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
events =
taskHistoryQueryMapper.queryHistoryEvents(
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
TaskHistoryEvent event = events.get(0);
assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.REQUESTED_REVIEW.getName());
event = historyService.getTaskHistoryEvent(event.getId());
assertThat(event.getDetails()).isNotNull();
JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes");
JSONObject expectedModified =
new JSONObject()
.put("newValue", task.getModified().toString())
.put("fieldName", "modified")
.put("oldValue", oldModified.toString());
JSONObject expectedState =
new JSONObject()
.put("newValue", "READY_FOR_REVIEW")
.put("fieldName", "state")
.put("oldValue", "CLAIMED");
JSONObject expectedOwner =
new JSONObject().put("newValue", "").put("fieldName", "owner").put("oldValue", "user-1-1");
JSONArray expectedChanges =
new JSONArray().put(expectedModified).put(expectedState).put(expectedOwner);
assertThat(changes.similar(expectedChanges)).isTrue();
}
}

8
lib/taskana-core/src/test/java/acceptance/jobs/TaskCleanupJobAccTest.java
View File

@ -50,7 +50,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
taskService.completeTask(taskId);
long totalTasksCount = taskService.createTaskQuery().count();
assertThat(totalTasksCount).isEqualTo(99);
assertThat(totalTasksCount).isEqualTo(100);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(false);
@ -58,14 +58,14 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
job.run();
totalTasksCount = taskService.createTaskQuery().count();
assertThat(totalTasksCount).isEqualTo(80);
assertThat(totalTasksCount).isEqualTo(81);
}
@WithAccessId(user = "admin")
@Test
void shouldCleanCompletedTasksUntilDateWithSameParentBussiness() throws Exception {
long totalTasksCount = taskService.createTaskQuery().count();
assertThat(totalTasksCount).isEqualTo(98);
assertThat(totalTasksCount).isEqualTo(99);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
@ -84,7 +84,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
job.run();
totalTasksCount = taskService.createTaskQuery().count();
assertThat(totalTasksCount).isEqualTo(78);
assertThat(totalTasksCount).isEqualTo(79);
}
@WithAccessId(user = "admin")

10
lib/taskana-core/src/test/java/acceptance/task/claim/SetOwnerAccTest.java
View File

@ -166,7 +166,7 @@ class SetOwnerAccTest extends AbstractAccTest {
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
assertThat(allTaskSummaries).hasSize(98);
assertThat(allTaskSummaries).hasSize(99);
assertThat(results.containsErrors()).isTrue();
Condition<Object> invalidTaskStateException =
@ -177,11 +177,11 @@ class SetOwnerAccTest extends AbstractAccTest {
c -> c.getClass() == MismatchedWorkbasketPermissionException.class,
"MismatchedWorkbasketPermissionException");
assertThat(results.getErrorMap())
.hasSize(96)
.hasSize(97)
.extractingFromEntries(Entry::getValue)
.hasOnlyElementsOfTypes(InvalidTaskStateException.class, NotAuthorizedException.class)
.areExactly(37, invalidTaskStateException)
.areExactly(59, mismatchedWorkbasketPermissionException);
.areExactly(60, mismatchedWorkbasketPermissionException);
}
@WithAccessId(user = "admin")
@ -193,10 +193,10 @@ class SetOwnerAccTest extends AbstractAccTest {
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
assertThat(allTaskSummaries).hasSize(98);
assertThat(allTaskSummaries).hasSize(99);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap())
.hasSize(50)
.hasSize(51)
.extractingFromEntries(Entry::getValue)
.hasOnlyElementsOfType(InvalidStateException.class);
}

4
lib/taskana-core/src/test/java/acceptance/task/complete/TerminateTaskAccTest.java
View File

@ -54,14 +54,14 @@ class TerminateTaskAccTest extends AbstractAccTest {
void should_TerminateTask_When_TaskStateIsClaimed() throws Exception {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();
assertThat(taskSummaries.size()).isEqualTo(20);
assertThat(taskSummaries.size()).isEqualTo(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(19);
assertThat(numTasksClaimed).isEqualTo(20);
numTasksTerminated = taskService.createTaskQuery().stateIn(TaskState.TERMINATED).count();
assertThat(numTasksTerminated).isEqualTo(6);
}

44
lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksAccTest.java
View File

@ -163,7 +163,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.ownerNotIn("user-b-1")
.orderByOwnerLongName(ASCENDING)
.list();
assertThat(tasks).extracting(TaskSummary::getOwnerLongName).hasSize(17).isSorted();
assertThat(tasks).extracting(TaskSummary::getOwnerLongName).hasSize(18).isSorted();
tasks =
taskService
@ -173,7 +173,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.orderByOwnerLongName(DESCENDING)
.list();
assertThat(tasks)
.hasSize(17)
.hasSize(18)
.extracting(TaskSummary::getOwnerLongName)
.isSortedAccordingTo(Comparator.reverseOrder());
}
@ -254,7 +254,7 @@ class QueryTasksAccTest extends AbstractAccTest {
throws InvalidArgumentException {
List<TaskSummary> query =
taskService.createTaskQuery().customAttributeIn(TaskCustomField.CUSTOM_1, "").list();
assertThat(query).hasSize(95);
assertThat(query).hasSize(96);
}
@Nested
@ -280,7 +280,7 @@ class QueryTasksAccTest extends AbstractAccTest {
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%ert"}, 3),
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"dd%"}, 1),
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%dd_"}, 1),
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 98),
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 99),
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"___"}, 4),
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"___"}, 4));
assertThat(list).hasSameSizeAs(TaskCustomField.values());
@ -312,22 +312,22 @@ class QueryTasksAccTest extends AbstractAccTest {
// carefully constructed to always return exactly 2 results
List<Triplet<TaskCustomField, String[], Integer>> list =
List.of(
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 97),
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 98),
Triplet.of(TaskCustomField.CUSTOM_2, new String[] {""}, 2),
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 97),
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 98),
Triplet.of(TaskCustomField.CUSTOM_4, new String[] {""}, 2),
Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 91),
Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 94),
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"custom7", "ijk"}, 96),
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"not_existing"}, 98),
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"custom9"}, 97),
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 97),
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 97),
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 97),
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 97),
Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 92),
Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 95),
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"custom7", "ijk"}, 97),
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"not_existing"}, 99),
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"custom9"}, 98),
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 98),
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 98),
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 98),
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 98),
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"abc"}, 0),
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 97),
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 97));
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 98),
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 98));
assertThat(list).hasSameSizeAs(TaskCustomField.values());
return DynamicTest.stream(
@ -376,7 +376,7 @@ class QueryTasksAccTest extends AbstractAccTest {
throws InvalidArgumentException {
List<TaskSummary> results =
taskService.createTaskQuery().customAttributeIn(TaskCustomField.CUSTOM_9, "").list();
assertThat(results).hasSize(96);
assertThat(results).hasSize(97);
}
@WithAccessId(user = "admin")
@ -388,7 +388,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.customAttributeIn(TaskCustomField.CUSTOM_9, "", null)
.list();
assertThat(results).hasSize(97);
assertThat(results).hasSize(98);
}
@WithAccessId(user = "admin")
@ -400,14 +400,14 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.customAttributeNotIn(TaskCustomField.CUSTOM_9, new String[] {null})
.list();
assertThat(results).hasSize(97);
assertThat(results).hasSize(98);
results =
taskService
.createTaskQuery()
.customAttributeNotIn(TaskCustomField.CUSTOM_9, null, "custom9")
.list();
assertThat(results).hasSize(96);
assertThat(results).hasSize(97);
results =
taskService
@ -415,7 +415,7 @@ class QueryTasksAccTest extends AbstractAccTest {
.customAttributeNotIn(TaskCustomField.CUSTOM_9, new String[] {null})
.customAttributeNotIn(TaskCustomField.CUSTOM_10, "custom10")
.list();
assertThat(results).hasSize(96);
assertThat(results).hasSize(97);
}
@WithAccessId(user = "admin")

4
lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByRoleAccTest.java
View File

@ -48,7 +48,7 @@ class QueryTasksByRoleAccTest extends AbstractAccTest {
switch (taskanaEngine.getCurrentUserContext().getUserid()) {
case "admin":
case "taskadmin":
expectedSize = 98;
expectedSize = 99;
break;
case "businessadmin":
case "monitor":
@ -58,7 +58,7 @@ class QueryTasksByRoleAccTest extends AbstractAccTest {
expectedSize = 26;
break;
case "user-1-1":
expectedSize = 8;
expectedSize = 9;
break;
case "user-taskrouter":
expectedSize = 0;

2
lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByTimeIntervalsAccTest.java
View File

@ -70,7 +70,7 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
assertThat(results).hasSize(39);
assertThat(results).hasSize(40);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getCreated();

4
lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksWithPaginationAccTest.java
View File

@ -31,9 +31,9 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
void testQueryAllPaged() {
TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery();
long numberOfTasks = taskQuery.count();
assertThat(numberOfTasks).isEqualTo(98);
assertThat(numberOfTasks).isEqualTo(99);
List<TaskSummary> tasks = taskQuery.orderByDue(DESCENDING).list();
assertThat(tasks).hasSize(98);
assertThat(tasks).hasSize(99);
List<TaskSummary> tasksp = taskQuery.orderByDue(DESCENDING).listPage(4, 5);
assertThat(tasksp).hasSize(5);
tasksp = taskQuery.orderByDue(DESCENDING).listPage(5, 5);

2
lib/taskana-core/src/test/java/acceptance/workbasket/delete/DeleteWorkbasketAccTest.java
View File

@ -183,6 +183,8 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
taskService.forceCompleteTask(task.getId());
task = (TaskImpl) taskService.getTask("TKI:100000000000000000000000000000000066");
taskService.forceCompleteTask(task.getId());
task = (TaskImpl) taskService.getTask("TKI:200000000000000000000000000000000066");
taskService.forceCompleteTask(task.getId());
boolean canBeDeletedNow = workbasketService.deleteWorkbasket(wb.getId());
assertThat(canBeDeletedNow).isFalse();