From ba5e582beb9265e4cd94f263d07959a6cc031e90 Mon Sep 17 00:00:00 2001 From: ryzheboka <25465835+ryzheboka@users.noreply.github.com> Date: Tue, 5 Jul 2022 17:40:03 +0200 Subject: [PATCH] TSK-1911: Fix details of TaskHistoryEvents --- .../sql/sample-data/object-reference.sql | 3 +- .../sql/test-data/object-reference.sql | 1 + ...eHistoryEventOnTaskCancelClaimAccTest.java | 120 +++++++++++------- .../CreateHistoryEventOnTaskClaimAccTest.java | 120 +++++++++++------- ...eateHistoryEventOnTaskTransferAccTest.java | 88 +++++++++---- .../query/QueryObjectReferenceAccTest.java | 4 +- ...ObjectReferencesWithPaginationAccTest.java | 20 +-- 7 files changed, 219 insertions(+), 137 deletions(-) diff --git a/common/taskana-common-data/src/main/resources/sql/sample-data/object-reference.sql b/common/taskana-common-data/src/main/resources/sql/sample-data/object-reference.sql index 14fa46fc4..eb6280601 100644 --- a/common/taskana-common-data/src/main/resources/sql/sample-data/object-reference.sql +++ b/common/taskana-common-data/src/main/resources/sql/sample-data/object-reference.sql @@ -1,4 +1,5 @@ INSERT INTO OBJECT_REFERENCE VALUES ('ID1', 'TKI:000000000000000000000000000000000000', 'Company1', 'System1', 'Instance1', 'Type1', 'Value1'); INSERT INTO OBJECT_REFERENCE VALUES ('ID2', 'TKI:000000000000000000000000000000000000', 'Company2', 'System2', 'Instance2', 'Type2', 'Value2'); INSERT INTO OBJECT_REFERENCE VALUES ('ID3', 'TKI:000000000000000000000000000000000001', 'Company3', 'System3', 'Instance3', 'Type3', 'Value2'); -INSERT INTO OBJECT_REFERENCE VALUES ('ID4', 'TKI:000000000000000000000000000000000002', 'Company1', 'System4', 'Instance4', 'Type2', 'Value2'); \ No newline at end of file +INSERT INTO OBJECT_REFERENCE VALUES ('ID4', 'TKI:000000000000000000000000000000000002', 'Company1', 'System4', 'Instance4', 'Type2', 'Value2'); +INSERT INTO OBJECT_REFERENCE VALUES ('ID5', 'TKI:000000000000000000000000000000000053', 'SomeCompany', 'SomeSystem', 'SomeInstance', 'SomeType', 'SomeValue'); \ No newline at end of file diff --git a/common/taskana-common-data/src/main/resources/sql/test-data/object-reference.sql b/common/taskana-common-data/src/main/resources/sql/test-data/object-reference.sql index 58084684b..eea7b1bea 100644 --- a/common/taskana-common-data/src/main/resources/sql/test-data/object-reference.sql +++ b/common/taskana-common-data/src/main/resources/sql/test-data/object-reference.sql @@ -1,3 +1,4 @@ INSERT INTO OBJECT_REFERENCE VALUES ('1', 'TaskId1', 'Company1', 'System1', 'Instance1', 'Type1', 'Value1'); INSERT INTO OBJECT_REFERENCE VALUES ('2', 'TaskId2', 'Company2', 'System2', 'Instance2', 'Type2', 'Value2'); INSERT INTO OBJECT_REFERENCE VALUES ('3', 'TaskId3', 'Company3', 'System3', 'Instance3', 'Type3', 'Value3'); +INSERT INTO OBJECT_REFERENCE VALUES ('ID5', 'TKI:000000000000000000000000000000000053', 'SomeCompany', 'SomeSystem', 'SomeInstance', 'SomeType', 'SomeValue'); \ No newline at end of file diff --git a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancelClaimAccTest.java b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancelClaimAccTest.java index 1493beb47..190337c56 100644 --- a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancelClaimAccTest.java +++ b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskCancelClaimAccTest.java @@ -5,11 +5,15 @@ import static org.assertj.core.api.Assertions.assertThat; import acceptance.AbstractAccTest; import java.time.Instant; import java.util.List; +import java.util.stream.Stream; import org.json.JSONArray; import org.json.JSONObject; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.TestFactory; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.function.ThrowingConsumer; +import pro.taskana.common.internal.util.Triplet; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl; @@ -28,66 +32,84 @@ class CreateHistoryEventOnTaskCancelClaimAccTest extends AbstractAccTest { private final SimpleHistoryServiceImpl historyService = getHistoryService(); @WithAccessId(user = "admin") - @Test - void should_CreateCancelClaimedHistoryEvent_When_TaskIsCancelClaimed() throws Exception { + @TestFactory + Stream should_CreateCancelClaimedHistoryEvent_When_TaskIsCancelClaimed() { - final String taskId = "TKI:000000000000000000000000000000000043"; - Task task = taskService.getTask(taskId); - final Instant oldModified = task.getModified(); - final Instant oldClaimed = task.getClaimed(); + List> list = + List.of( + Triplet.of( + "With Attachment and secondary Object Reference", + "TKI:000000000000000000000000000000000002", + "user-1-1"), + Triplet.of( + "Without Attachment and secondary Object References", + "TKI:000000000000000000000000000000000043", + "user-b-1")); + ThrowingConsumer> test = + t -> { + String taskId = t.getMiddle(); + Task task = taskService.getTask(taskId); + final Instant oldModified = task.getModified(); + final Instant oldClaimed = task.getClaimed(); - TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); - List events = - taskHistoryQueryMapper.queryHistoryEvents( - (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); + TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); + List events = + taskHistoryQueryMapper.queryHistoryEvents( + (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); - assertThat(events).isEmpty(); + assertThat(events).isEmpty(); - assertThat(task.getState()).isEqualTo(TaskState.CLAIMED); - task = taskService.forceCancelClaim(taskId); - assertThat(task.getState()).isEqualTo(TaskState.READY); + assertThat(task.getState()).isEqualTo(TaskState.CLAIMED); + task = taskService.forceCancelClaim(taskId); + assertThat(task.getState()).isEqualTo(TaskState.READY); - events = - taskHistoryQueryMapper.queryHistoryEvents( - (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); + events = + taskHistoryQueryMapper.queryHistoryEvents( + (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); - assertThat(events).hasSize(1); + assertThat(events).hasSize(1); - TaskHistoryEvent event = events.get(0); + TaskHistoryEvent event = events.get(0); - assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.CLAIM_CANCELLED.getName()); + assertThat(event.getEventType()) + .isEqualTo(TaskHistoryEventType.CLAIM_CANCELLED.getName()); - event = historyService.getTaskHistoryEvent(event.getId()); + event = historyService.getTaskHistoryEvent(event.getId()); - assertThat(event.getDetails()).isNotNull(); + assertThat(event.getDetails()).isNotNull(); - JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes"); + JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes"); + String oldOwner = t.getRight(); + JSONObject expectedClaimed = + new JSONObject() + .put("newValue", "") + .put("fieldName", "claimed") + .put("oldValue", oldClaimed.toString()); + JSONObject expectedModified = + new JSONObject() + .put("newValue", task.getModified().toString()) + .put("fieldName", "modified") + .put("oldValue", oldModified.toString()); + JSONObject expectedState = + new JSONObject() + .put("newValue", "READY") + .put("fieldName", "state") + .put("oldValue", "CLAIMED"); + JSONObject expectedOwner = + new JSONObject() + .put("newValue", "") + .put("fieldName", "owner") + .put("oldValue", oldOwner); - JSONObject expectedClaimed = - new JSONObject() - .put("newValue", "") - .put("fieldName", "claimed") - .put("oldValue", oldClaimed.toString()); - JSONObject expectedModified = - new JSONObject() - .put("newValue", task.getModified().toString()) - .put("fieldName", "modified") - .put("oldValue", oldModified.toString()); - JSONObject expectedState = - new JSONObject() - .put("newValue", "READY") - .put("fieldName", "state") - .put("oldValue", "CLAIMED"); - JSONObject expectedOwner = - new JSONObject().put("newValue", "").put("fieldName", "owner").put("oldValue", "user-b-1"); + JSONArray expectedChanges = + new JSONArray() + .put(expectedClaimed) + .put(expectedModified) + .put(expectedState) + .put(expectedOwner); - JSONArray expectedChanges = - new JSONArray() - .put(expectedClaimed) - .put(expectedModified) - .put(expectedState) - .put(expectedOwner); - - assertThat(changes.similar(expectedChanges)).isTrue(); + assertThat(changes.similar(expectedChanges)).isTrue(); + }; + return DynamicTest.stream(list.iterator(), Triplet::getLeft, test); } } diff --git a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskClaimAccTest.java b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskClaimAccTest.java index e3db329f4..511b23f45 100644 --- a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskClaimAccTest.java +++ b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskClaimAccTest.java @@ -5,11 +5,15 @@ import static org.assertj.core.api.Assertions.assertThat; import acceptance.AbstractAccTest; import java.time.Instant; import java.util.List; +import java.util.stream.Stream; import org.json.JSONArray; import org.json.JSONObject; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.TestFactory; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.function.ThrowingConsumer; +import pro.taskana.common.internal.util.Pair; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl; @@ -28,66 +32,86 @@ class CreateHistoryEventOnTaskClaimAccTest extends AbstractAccTest { private final SimpleHistoryServiceImpl historyService = getHistoryService(); @WithAccessId(user = "admin") - @Test - void should_CreateClaimedHistoryEvent_When_TaskIsClaimed() throws Exception { - final String taskId = "TKI:000000000000000000000000000000000047"; - final Instant oldModified = taskService.getTask(taskId).getModified(); + @TestFactory + Stream should_CreateClaimedHistoryEvent_When_TaskIsClaimed() { + List> list = + List.of( + Pair.of( + "With Attachment and secondary Object Reference", + "TKI:000000000000000000000000000000000053"), + Pair.of( + "Without Attachment and secondary Object References", + "TKI:000000000000000000000000000000000047")); - TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); + ThrowingConsumer> test = + pair -> { + final Instant oldModified = taskService.getTask(pair.getRight()).getModified(); - List events = - taskHistoryQueryMapper.queryHistoryEvents( - (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); + TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); - assertThat(events).isEmpty(); + List events = + taskHistoryQueryMapper.queryHistoryEvents( + (TaskHistoryQueryImpl) + historyService.createTaskHistoryQuery().taskIdIn(pair.getRight())); - assertThat(taskService.getTask(taskId).getState()).isEqualTo(TaskState.READY); - Task task = taskService.claim(taskId); + assertThat(events).isEmpty(); - assertThat(task.getState()).isEqualTo(TaskState.CLAIMED); + assertThat(taskService.getTask(pair.getRight()).getState()).isEqualTo(TaskState.READY); + Task task = taskService.claim(pair.getRight()); - events = - taskHistoryQueryMapper.queryHistoryEvents( - (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); + assertThat(task.getState()).isEqualTo(TaskState.CLAIMED); - TaskHistoryEvent event = events.get(0); + events = + taskHistoryQueryMapper.queryHistoryEvents( + (TaskHistoryQueryImpl) + historyService.createTaskHistoryQuery().taskIdIn(pair.getRight())); - assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.CLAIMED.getName()); + TaskHistoryEvent event = events.get(0); - event = historyService.getTaskHistoryEvent(event.getId()); + assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.CLAIMED.getName()); - assertThat(event.getDetails()).isNotNull(); + event = historyService.getTaskHistoryEvent(event.getId()); - JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes"); + assertThat(event.getDetails()).isNotNull(); - JSONObject expectedClaimed = - new JSONObject() - .put("newValue", task.getModified().toString()) - .put("fieldName", "claimed") - .put("oldValue", ""); - JSONObject expectedModified = - new JSONObject() - .put("newValue", task.getModified().toString()) - .put("fieldName", "modified") - .put("oldValue", oldModified.toString()); - JSONObject expectedState = - new JSONObject() - .put("newValue", "CLAIMED") - .put("fieldName", "state") - .put("oldValue", "READY"); - JSONObject expectedOwner = - new JSONObject().put("newValue", "admin").put("fieldName", "owner").put("oldValue", ""); - JSONObject expectedIsRead = - new JSONObject().put("newValue", true).put("fieldName", "isRead").put("oldValue", false); + JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes"); - JSONArray expectedChanges = - new JSONArray() - .put(expectedClaimed) - .put(expectedModified) - .put(expectedState) - .put(expectedOwner) - .put(expectedIsRead); + JSONObject expectedClaimed = + new JSONObject() + .put("newValue", task.getModified().toString()) + .put("fieldName", "claimed") + .put("oldValue", ""); + JSONObject expectedModified = + new JSONObject() + .put("newValue", task.getModified().toString()) + .put("fieldName", "modified") + .put("oldValue", oldModified.toString()); + JSONObject expectedState = + new JSONObject() + .put("newValue", "CLAIMED") + .put("fieldName", "state") + .put("oldValue", "READY"); + JSONObject expectedOwner = + new JSONObject() + .put("newValue", "admin") + .put("fieldName", "owner") + .put("oldValue", ""); + JSONObject expectedIsRead = + new JSONObject() + .put("newValue", true) + .put("fieldName", "isRead") + .put("oldValue", false); - assertThat(changes.similar(expectedChanges)).isTrue(); + JSONArray expectedChanges = + new JSONArray() + .put(expectedClaimed) + .put(expectedModified) + .put(expectedState) + .put(expectedOwner) + .put(expectedIsRead); + + assertThat(changes.similar(expectedChanges)).isTrue(); + }; + return DynamicTest.stream(list.iterator(), Pair::getLeft, test); } } diff --git a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java index 9ec7eab67..1e3384696 100644 --- a/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java +++ b/history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/CreateHistoryEventOnTaskTransferAccTest.java @@ -4,7 +4,9 @@ import static org.assertj.core.api.Assertions.assertThat; import static pro.taskana.common.internal.util.CheckedConsumer.wrap; import acceptance.AbstractAccTest; +import java.util.ArrayList; import java.util.List; +import java.util.Map; import java.util.function.Consumer; import java.util.stream.Stream; import org.json.JSONArray; @@ -14,6 +16,7 @@ import org.junit.jupiter.api.TestFactory; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.function.ThrowingConsumer; +import pro.taskana.common.internal.util.Quadruple; import pro.taskana.common.internal.util.Triplet; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; @@ -35,23 +38,39 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest { @WithAccessId(user = "admin") @TestFactory Stream should_CreateTransferredHistoryEvent_When_TaskIsTransferred() { - List>> testCases = + List>> testCases = List.of( - Triplet.of( - "Using WorkbasketId", + /* + The workbasketId of the source Workbasket is parametrized. Putting the tested Tasks + into the same Workbasket would result in changes to the test data. This would require + changing tests that already use the tested Tasks. That's why workbasketId is + parametrized. + */ + Quadruple.of( + "Using WorkbasketId; Task doesn't have an Attachment" + + " or any secondary Object References", "TKI:000000000000000000000000000000000003", + "WBI:100000000000000000000000000000000001", wrap( (String taskId) -> taskService.transfer(taskId, "WBI:100000000000000000000000000000000006"))), - Triplet.of( + Quadruple.of( + "Using WorkbasketId; Task has Attachment and secondary Object Reference", + "TKI:000000000000000000000000000000000053", + "WBI:100000000000000000000000000000000015", + wrap( + (String taskId) -> + taskService.transfer(taskId, "WBI:100000000000000000000000000000000006"))), + Quadruple.of( "Using WorkbasketKey and Domain", "TKI:000000000000000000000000000000000004", + "WBI:100000000000000000000000000000000001", wrap((String taskId) -> taskService.transfer(taskId, "USER-1-1", "DOMAIN_A")))); - ThrowingConsumer>> test = - t -> { - String taskId = t.getMiddle(); - Consumer transferMethod = t.getRight(); + ThrowingConsumer>> test = + q -> { + String taskId = q.getSecond(); + Consumer transferMethod = q.getFourth(); TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); @@ -68,42 +87,63 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest { (TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId)); assertThat(events).hasSize(1); + String sourceWorkbasketId = q.getThird(); assertTransferHistoryEvent( events.get(0).getId(), - "WBI:100000000000000000000000000000000001", + sourceWorkbasketId, "WBI:100000000000000000000000000000000006", "admin"); }; - return DynamicTest.stream(testCases.iterator(), Triplet::getLeft, test); + return DynamicTest.stream(testCases.iterator(), Quadruple::getFirst, test); } @WithAccessId(user = "admin") @TestFactory Stream should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() { - List, Consumer>>> testCases = + List, Consumer>>> testCases = List.of( + /* + The workbasketId of the source Workbasket is parametrized. Putting the tested Tasks + into the same Workbasket would result in changes to the test data. This would require + changing tests that already use the tested Tasks. That's why workbasketId is + parametrized. + */ Triplet.of( "Using WorkbasketId", - List.of( - "TKI:000000000000000000000000000000000021", - "TKI:000000000000000000000000000000000022"), + Map.ofEntries( + Map.entry( + "TKI:000000000000000000000000000000000021", + "WBI:100000000000000000000000000000000001"), + Map.entry( + "TKI:000000000000000000000000000000000022", + "WBI:100000000000000000000000000000000001"), + Map.entry( + "TKI:000000000000000000000000000000000002", + "WBI:100000000000000000000000000000000006")), wrap( (List taskIds) -> taskService.transferTasks( "WBI:100000000000000000000000000000000007", taskIds))), Triplet.of( "Using WorkbasketKey and Domain", - List.of( - "TKI:000000000000000000000000000000000023", - "TKI:000000000000000000000000000000000024"), + Map.ofEntries( + Map.entry( + "TKI:000000000000000000000000000000000023", + "WBI:100000000000000000000000000000000001"), + Map.entry( + "TKI:000000000000000000000000000000000024", + "WBI:100000000000000000000000000000000001"), + Map.entry( + "TKI:000000000000000000000000000000000055", + "WBI:100000000000000000000000000000000015")), wrap( (List taskIds) -> taskService.transferTasks("USER-1-2", "DOMAIN_A", taskIds)))); - ThrowingConsumer, Consumer>>> test = + ThrowingConsumer, Consumer>>> test = t -> { - List taskIds = t.getMiddle(); + Map taskIds = t.getMiddle(); Consumer> transferMethod = t.getRight(); TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper(); @@ -113,27 +153,27 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest { (TaskHistoryQueryImpl) historyService .createTaskHistoryQuery() - .taskIdIn(taskIds.toArray(new String[0]))); + .taskIdIn(taskIds.keySet().toArray(new String[0]))); assertThat(events).isEmpty(); - transferMethod.accept(taskIds); + transferMethod.accept(new ArrayList<>(taskIds.keySet())); events = taskHistoryQueryMapper.queryHistoryEvents( (TaskHistoryQueryImpl) historyService .createTaskHistoryQuery() - .taskIdIn(taskIds.toArray(new String[0]))); + .taskIdIn(taskIds.keySet().toArray(new String[0]))); assertThat(events) .extracting(TaskHistoryEvent::getTaskId) - .containsExactlyInAnyOrderElementsOf(taskIds); + .containsExactlyInAnyOrderElementsOf(taskIds.keySet()); for (TaskHistoryEvent event : events) { assertTransferHistoryEvent( event.getId(), - "WBI:100000000000000000000000000000000001", + taskIds.get(event.getTaskId()), "WBI:100000000000000000000000000000000007", "admin"); } diff --git a/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferenceAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferenceAccTest.java index 7015f285a..e6f9e35f4 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferenceAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferenceAccTest.java @@ -18,10 +18,10 @@ class QueryObjectReferenceAccTest extends AbstractAccTest { void testQueryObjectReferenceValuesForColumnName() { TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery(); List columnValues = taskQuery.createObjectReferenceQuery().listValues(COMPANY, null); - assertThat(columnValues).hasSize(3); + assertThat(columnValues).hasSize(4); columnValues = taskQuery.createObjectReferenceQuery().listValues(SYSTEM, null); - assertThat(columnValues).hasSize(3); + assertThat(columnValues).hasSize(4); columnValues = taskQuery.createObjectReferenceQuery().systemIn("System1").listValues(SYSTEM, null); diff --git a/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferencesWithPaginationAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferencesWithPaginationAccTest.java index a9cbf7623..e556050f6 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferencesWithPaginationAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferencesWithPaginationAccTest.java @@ -29,13 +29,13 @@ class QueryObjectReferencesWithPaginationAccTest extends AbstractAccTest { void testGetFirstPageOfObjectRefQueryWithOffset() { List results = objRefQuery.list(0, 5); - assertThat(results).hasSize(3); + assertThat(results).hasSize(4); } @Test void testGetSecondPageOfObjectRefQueryWithOffset() { List results = objRefQuery.list(2, 5); - assertThat(results).hasSize(1); + assertThat(results).hasSize(2); } @Test @@ -59,25 +59,19 @@ class QueryObjectReferencesWithPaginationAccTest extends AbstractAccTest { int pageNumber = 1; int pageSize = 10; List results = objRefQuery.listPage(pageNumber, pageSize); - assertThat(results).hasSize(3); + assertThat(results).hasSize(4); // Getting full page pageNumber = 2; pageSize = 2; results = objRefQuery.listPage(pageNumber, pageSize); - assertThat(results).hasSize(1); + assertThat(results).hasSize(2); // Getting last results on 1 big page pageNumber = 1; pageSize = 100; results = objRefQuery.listPage(pageNumber, pageSize); - assertThat(results).hasSize(3); - - // Getting last results on multiple pages - pageNumber = 2; - pageSize = 2; - results = objRefQuery.listPage(pageNumber, pageSize); - assertThat(results).hasSize(1); + assertThat(results).hasSize(4); } @Test @@ -98,12 +92,12 @@ class QueryObjectReferencesWithPaginationAccTest extends AbstractAccTest { pageNumber = -1; pageSize = 10; results = objRefQuery.listPage(pageNumber, pageSize); - assertThat(results).hasSize(3); + assertThat(results).hasSize(4); } @Test void testCountOfClassificationsQuery() { long count = objRefQuery.count(); - assertThat(count).isEqualTo(3L); + assertThat(count).isEqualTo(4L); } }