From 8047e97c15b4d4707019546af3df19dfdd1cd3d9 Mon Sep 17 00:00:00 2001 From: Lia Lissmann <89016649+LiaLissmann@users.noreply.github.com> Date: Tue, 5 Oct 2021 14:37:59 +0200 Subject: [PATCH] TSK-1743: Deleted some Tests and started grouping tests together --- .../acceptance/task/CreateTaskAccTest.java | 12 +- .../QueryTaskByClassificationNameAccTest.java | 154 --- .../task/QueryTaskWithAttachmentAccTest.java | 83 -- .../acceptance/task/QueryTasksAccTest.java | 930 +++--------------- .../QueryTasksByObjectReferenceAccTest.java | 138 --- .../task/QueryTasksByRoleAccTest.java | 82 +- .../QueryTasksByTimeIntervalsAccTest.java | 368 ++++--- .../QueryTasksByWildcardSearchAccTest.java | 163 +-- .../task/QueryTasksByWorkbasketAccTest.java | 83 +- .../task/QueryTasksListValuesAccTest.java | 218 ++-- .../task/QueryTasksWithPaginationAccTest.java | 291 +++--- .../task/QueryTasksWithSortingAccTest.java | 923 ++++++++++++----- 12 files changed, 1489 insertions(+), 1956 deletions(-) delete mode 100644 lib/taskana-core/src/test/java/acceptance/task/QueryTaskWithAttachmentAccTest.java delete mode 100644 lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java diff --git a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java index ddb479141..1b37a385d 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java @@ -49,6 +49,15 @@ class CreateTaskAccTest extends AbstractAccTest { private final ClassificationService classificationService = taskanaEngine.getClassificationService(); + @WithAccessId(user = "user-1-1") + @Test + void should_NotSetAttachmentSummariesToNull_When_CreatingNewTaskWithTaskService() { + TaskService taskService = taskanaEngine.getTaskService(); + Task task = taskService.newTask("WBI:100000000000000000000000000000000006"); + assertThat(task.getAttachments()).isNotNull(); + assertThat(task.asSummary().getAttachmentSummaries()).isNotNull(); + } + @WithAccessId(user = "user-1-1") @Test void should_BeAbleToCreateNewTask_When_TaskCopy() throws Exception { @@ -631,8 +640,7 @@ class CreateTaskAccTest extends AbstractAccTest { createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null)); testCreateTask.accept( createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567")); - testCreateTask.accept( - createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + testCreateTask.accept(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); } @WithAccessId(user = "user-1-1") diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTaskByClassificationNameAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTaskByClassificationNameAccTest.java index 18c7d0a00..6deb4791c 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTaskByClassificationNameAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTaskByClassificationNameAccTest.java @@ -1,20 +1,10 @@ package acceptance.task; -import static org.assertj.core.api.Assertions.assertThat; - import acceptance.AbstractAccTest; -import java.util.List; -import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.test.security.JaasExtension; -import pro.taskana.common.test.security.WithAccessId; -import pro.taskana.task.api.TaskQuery; -import pro.taskana.task.api.TaskQueryColumnName; -import pro.taskana.task.api.TaskService; -import pro.taskana.task.api.models.AttachmentSummary; -import pro.taskana.task.api.models.TaskSummary; /** * Acceptance test for the usecase of adding/removing an attachment of a task and update the result @@ -25,148 +15,4 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest { private static SortDirection asc = SortDirection.ASCENDING; private static SortDirection desc = SortDirection.DESCENDING; - - QueryTaskByClassificationNameAccTest() { - super(); - } - - @WithAccessId(user = "admin") - @Test - void testQueryTaskValuesForAttachmentClassificationName() { - TaskService taskService = taskanaEngine.getTaskService(); - List columnValueList = - taskService - .createTaskQuery() - .ownerLike("%user%") - .orderByOwner(desc) - .listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, null); - assertThat(columnValueList).hasSize(8); - } - - @WithAccessId(user = "admin") - @Test - void testQueryTaskValuesForClassificationName() { - TaskService taskService = taskanaEngine.getTaskService(); - List columnValueList = - taskService - .createTaskQuery() - .ownerLike("%user%") - .orderByClassificationName(asc) - .listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null); - assertThat(columnValueList).hasSize(5); - } - - @WithAccessId(user = "user-1-1") - @Test - void testQueryByClassificationNameIn() { - TaskService taskService = taskanaEngine.getTaskService(); - List tasks = - taskService.createTaskQuery().classificationNameIn("Dynamik-Ablehnung").list(); - assertThat(tasks).hasSize(1); - - List attachmentSummaries = tasks.get(0).getAttachmentSummaries(); - assertThat(attachmentSummaries).hasSize(2); - - tasks = - taskService - .createTaskQuery() - .classificationNameIn("Dynamik-Ablehnung") - .orderByClassificationName(SortDirection.ASCENDING) - .list(); - assertThat(tasks).hasSize(1); - } - - @WithAccessId(user = "user-1-1", groups = GROUP_1_DN) - @Test - void testQueryByClassificationNameLike() { - TaskService taskService = taskanaEngine.getTaskService(); - List tasks = - taskService - .createTaskQuery() - .classificationNameLike("Dynamik%", "Widerruf") - .orderByClassificationName(SortDirection.ASCENDING) - .list(); - assertThat(tasks).hasSize(32); - - // without sort, the same number of tasks should be returned - tasks = taskService.createTaskQuery().classificationNameLike("Dynamik%", "Widerruf").list(); - assertThat(tasks).hasSize(32); - } - - @WithAccessId(user = "user-1-1") - @Test - void testSelectByAttachmentClassificationNameLike() { - TaskService taskService = taskanaEngine.getTaskService(); - // find Task with attachment classification names - List tasks = - taskService - .createTaskQuery() - .attachmentClassificationNameLike("Widerruf", "Beratungsprotokoll", "Dynamik%") - .orderByAttachmentClassificationName(SortDirection.ASCENDING) - .list(); - assertThat(tasks).hasSize(10); - // make sure that unordered query returns the same number of objects - tasks = - taskService - .createTaskQuery() - .attachmentClassificationNameLike("Widerruf", "Beratungsprotokoll", "Dynamik%") - .list(); - assertThat(tasks).hasSize(10); - } - - @WithAccessId(user = "user-1-1") - @Test - void testSelectByAttachmentClassificationNameIn() { - TaskService taskService = taskanaEngine.getTaskService(); - // find Task with attachment classification names - List tasks = - taskService - .createTaskQuery() - .attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung") - .orderByAttachmentClassificationName(SortDirection.ASCENDING) - .list(); - assertThat(tasks).hasSize(7); - // make sure that unordered query returns the same number of objects - tasks = - taskService - .createTaskQuery() - .attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung") - .list(); - assertThat(tasks).hasSize(7); - } - - @WithAccessId(user = "user-1-1") - @Test - void testQueryAndCountMatchForClassificationName() { - TaskService taskService = taskanaEngine.getTaskService(); - TaskQuery taskQuery = taskService.createTaskQuery(); - List tasks = - taskQuery.classificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung").list(); - long numberOfTasks = - taskQuery.classificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung").count(); - assertThat(tasks).hasSize((int) numberOfTasks); - } - - @WithAccessId(user = "user-1-1") - @Test - void testQueryAndCountForAttachmentClassificationName() { - TaskService taskService = taskanaEngine.getTaskService(); - TaskQuery taskQuery = taskService.createTaskQuery(); - List tasks = - taskQuery - .attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung") - .list(); - // we expect 4 result objects in this case, because task - // TKI:000000000000000000000000000000000001 has 2 attachments with different Classifications - // therefore task TKI:000000000000000000000000000000000001 occurs twice in the result set - assertThat(tasks).hasSize(7); - long numberOfTasks = - taskQuery - .attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung") - .count(); - assertThat(numberOfTasks).isEqualTo(6); - // the count returns only the number of tasks that have an attachment with the specified - // classification name. - // therefore, task 001 is counted only once. - } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTaskWithAttachmentAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTaskWithAttachmentAccTest.java deleted file mode 100644 index f4135fdf4..000000000 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTaskWithAttachmentAccTest.java +++ /dev/null @@ -1,83 +0,0 @@ -package acceptance.task; - -import static org.assertj.core.api.Assertions.assertThat; - -import acceptance.AbstractAccTest; -import java.util.Comparator; -import java.util.List; -import java.util.stream.Collectors; -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.models.Attachment; -import pro.taskana.task.api.models.AttachmentSummary; -import pro.taskana.task.api.models.Task; -import pro.taskana.task.api.models.TaskSummary; - -/** - * Acceptance test for the usecase of adding/removing an attachment of a task and update the result - * correctly. - */ -@ExtendWith(JaasExtension.class) -class QueryTaskWithAttachmentAccTest extends AbstractAccTest { - - private static final Comparator REFERENCE_COMPARATOR = (o1, o2) -> o1 == o2 ? 0 : -1; - - @WithAccessId(user = "user-1-1") - @Test - void should_ReturnTaskSummaryIncludingAttachments_When_QueryingTaskWithAttachments() { - TaskService taskService = taskanaEngine.getTaskService(); - List tasks = taskService.createTaskQuery().classificationKeyIn("L110102").list(); - assertThat(tasks).hasSize(1); - - List attachmentSummaries = tasks.get(0).getAttachmentSummaries(); - assertThat(attachmentSummaries).hasSize(2); - } - - @WithAccessId(user = "user-1-2") - @Test - void should_ReturnTaskSummaryWithEmptyAttachments_When_QueryingTaskWithoutAttachments() { - TaskService taskService = taskanaEngine.getTaskService(); - List tasks = taskService.createTaskQuery().list(); - assertThat(tasks).hasSize(30); - - List attachmentSummaries = tasks.get(0).getAttachmentSummaries(); - assertThat(attachmentSummaries).isEmpty(); - } - - @WithAccessId(user = "user-1-1") - @Test - void should_NotSetAttachmentSummariesToNull_When_CreatingNewTaskWithTaskService() { - TaskService taskService = taskanaEngine.getTaskService(); - Task task = taskService.newTask("WBI:100000000000000000000000000000000006"); - assertThat(task.getAttachments()).isNotNull(); - assertThat(task.asSummary().getAttachmentSummaries()).isNotNull(); - } - - @WithAccessId(user = "user-1-1") - @Test - void should_ReturnTheSameAttachmentsOfATaskSummary_When_UsingTaskQueryAndTaskService() - throws Exception { - TaskService taskService = taskanaEngine.getTaskService(); - // find Task with ID TKI:00...00 - List tasks = - taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list(); - assertThat(tasks).hasSize(1); - List queryAttachmentSummaries = tasks.get(0).getAttachmentSummaries(); - - Task originalTask = taskService.getTask("TKI:000000000000000000000000000000000000"); - List originalAttachments = - originalTask.getAttachments().stream() - .map(Attachment::asSummary) - .collect(Collectors.toList()); - - assertThat(queryAttachmentSummaries) - .hasSize(originalAttachments.size()) - .containsExactlyInAnyOrderElementsOf(originalAttachments) // same values - .usingElementComparator(REFERENCE_COMPARATOR) - .doesNotContainAnyElementsOf(originalAttachments); // but not same reference - } -} diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java index 1ea2b841a..639646d43 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java @@ -1,58 +1,41 @@ package acceptance.task; -import static java.lang.String.CASE_INSENSITIVE_ORDER; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.eq; -import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING; -import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING; import static pro.taskana.task.api.TaskCustomField.CUSTOM_7; import acceptance.AbstractAccTest; import acceptance.TaskTestMapper; import acceptance.TaskanaEngineProxy; -import java.time.Instant; -import java.util.Arrays; -import java.util.Comparator; -import java.util.Iterator; import java.util.List; import java.util.Map; -import java.util.Objects; -import java.util.stream.Collectors; import java.util.stream.Stream; import org.apache.ibatis.session.Configuration; import org.apache.ibatis.session.SqlSession; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestFactory; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.MockedStatic; import org.mockito.Mockito; +import org.mockito.internal.stubbing.answers.CallsRealMethods; -import pro.taskana.classification.api.models.ClassificationSummary; -import pro.taskana.common.api.BaseQuery.SortDirection; -import pro.taskana.common.api.TimeInterval; import pro.taskana.common.api.exceptions.InvalidArgumentException; import pro.taskana.common.internal.util.CollectionUtil; import pro.taskana.common.internal.util.Triplet; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; import pro.taskana.task.api.TaskCustomField; -import pro.taskana.task.api.TaskQuery; -import pro.taskana.task.api.TaskQueryColumnName; -import pro.taskana.task.api.TaskState; -import pro.taskana.task.api.models.Attachment; -import pro.taskana.task.api.models.AttachmentSummary; -import pro.taskana.task.api.models.ObjectReference; import pro.taskana.task.api.models.Task; import pro.taskana.task.api.models.TaskSummary; import pro.taskana.task.internal.models.TaskImpl; -import pro.taskana.user.api.exceptions.UserNotFoundException; -import pro.taskana.workbasket.api.models.WorkbasketSummary; /** Acceptance test for all "query tasks with sorting" scenarios. */ @ExtendWith(JaasExtension.class) @@ -246,799 +229,172 @@ class QueryTasksAccTest extends AbstractAccTest { @WithAccessId(user = "admin") @Test void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() { - try (MockedStatic listUtilMock = Mockito.mockStatic(CollectionUtil.class)) { - listUtilMock - .when(() -> CollectionUtil.partitionBasedOnSize(any(), anyInt())) - .thenCallRealMethod(); - - taskService.createTaskQuery().list(); + try (MockedStatic listUtilMock = + Mockito.mockStatic(CollectionUtil.class, new CallsRealMethods())) { + TASK_SERVICE.createTaskQuery().list(); listUtilMock.verify(() -> CollectionUtil.partitionBasedOnSize(any(), eq(32000))); } } - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForOwnerLike() { - List results = - taskService.createTaskQuery().ownerLike("%a%", "%u%").orderByCreated(ASCENDING).list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class CustomAttributeTest { - assertThat(results).hasSize(39).extracting(TaskSummary::getCreated).isSorted(); - } + @WithAccessId(user = "admin") + @TestFactory + Stream should_ReturnCorrectResults_When_QueryingForCustomXStatements() { + List> list = + List.of( + Triplet.of( + TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3), + Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1), + Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2), + Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6), + Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5), + Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3), + Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3), + Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3), + Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3), + Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88), + Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3), + Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3)); + assertThat(list).hasSameSizeAs(TaskCustomField.values()); - @WithAccessId(user = "admin") - @Test - void should_FilterOutOwner_When_OwnerNotInIsSet() { - List results = - taskService.createTaskQuery().ownerNotIn("user-1-1", "user-1-2").list(); + return DynamicTest.stream( + list.iterator(), + t -> t.getLeft().name(), + t -> testQueryForCustomXLikeAndIn(t.getLeft(), t.getMiddle(), t.getRight())); + } - assertThat(results).hasSize(3).extracting(TaskSummary::getOwner).containsOnly("user-b-1"); - } + void testQueryForCustomXLikeAndIn( + TaskCustomField customField, String[] searchArguments, int expectedResult) + throws Exception { + List results = + TASK_SERVICE.createTaskQuery().customAttributeLike(customField, searchArguments).list(); + assertThat(results).hasSize(expectedResult); - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForDescription() { - List results = taskService.createTaskQuery().descriptionLike("Lorem%").list(); - assertThat(results).hasSize(7); - } + String[] customAttributes = + results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new); - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForPriority() { - List results = taskService.createTaskQuery().priorityIn(1).list(); - assertThat(results).hasSize(2); - } + List result2 = + TASK_SERVICE.createTaskQuery().customAttributeIn(customField, customAttributes).list(); + assertThat(result2).hasSize(expectedResult); + } - @WithAccessId(user = "admin") - @Test - void testQueryForName() { + @WithAccessId(user = "admin") + @TestFactory + Stream should_ReturnCorrectResults_When_QueryingForCustomXNotIn() { + // carefully constructed to always return exactly 2 results + List> list = + List.of( + Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 2), + Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 2), + Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 2), + Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 2), + Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2), + Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 2), + Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 2), + Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 2), + Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 2), + Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"abc"}, 2), + Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 2), + Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 2)); + assertThat(list).hasSameSizeAs(TaskCustomField.values()); - List results = taskService.createTaskQuery().nameLike("task%").list(); - assertThat(results).hasSize(7); + return DynamicTest.stream( + list.iterator(), + t -> t.getLeft().name(), + t -> testQueryForCustomXNotIn(t.getLeft(), t.getMiddle(), t.getRight())); + } - String[] ids = results.stream().map(TaskSummary::getName).toArray(String[]::new); + void testQueryForCustomXNotIn( + TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception { + long results = + TASK_SERVICE.createTaskQuery().customAttributeNotIn(customField, searchArguments).count(); + assertThat(results).isEqualTo(expectedCount); + } - List result2 = taskService.createTaskQuery().nameIn(ids).list(); - assertThat(result2).hasSize(7); - } + @WithAccessId(user = "admin") + @Test + void testQueryForCustom7WithExceptionInLike() { + assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7).list()) + .isInstanceOf(InvalidArgumentException.class); + } - @WithAccessId(user = "admin") - @Test - void testQueryForClassificationKey() { + @WithAccessId(user = "admin") + @Test + void testQueryForCustom7WithExceptionInIn() throws Exception { + List results = + TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list(); + assertThat(results).isEmpty(); - List results = taskService.createTaskQuery().classificationKeyLike("L10%").list(); - assertThat(results).hasSize(78); + assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7).list()) + .isInstanceOf(InvalidArgumentException.class); + } - String[] ids = - results.stream().map(t -> t.getClassificationSummary().getKey()).toArray(String[]::new); + @WithAccessId(user = "admin") + @Test + void testQueryForCustom7WithException() throws Exception { + List results = + TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list(); + assertThat(results).hasSize(2); - List result2 = taskService.createTaskQuery().classificationKeyIn(ids).list(); - assertThat(result2).hasSize(78); + String[] ids = + results.stream().map(t -> t.getCustomAttribute(CUSTOM_7)).toArray(String[]::new); - List result3 = - taskService.createTaskQuery().classificationKeyNotIn("T2100", "T2000").list(); - assertThat(result3).hasSize(83); + List result2 = + TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list(); + assertThat(result2).hasSize(2); + } - List result4 = - taskService.createTaskQuery().classificationKeyNotIn("L1050", "L1060", "T2100").list(); - assertThat(result4).hasSize(10); - } + @WithAccessId(user = "admin") + @Test + void testQueryTaskByCustomAttributes() throws Exception { + Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A"); + newTask.setPrimaryObjRef( + createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); + newTask.setClassificationKey("T2100"); + Map customAttributesForCreate = + createSimpleCustomPropertyMap(20000); // about 1 Meg + newTask.setCustomAttributeMap(customAttributesForCreate); + Task createdTask = TASK_SERVICE.createTask(newTask); - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentInSummary() throws Exception { + assertThat(createdTask).isNotNull(); + // query the task by custom attributes + TaskanaEngineProxy engineProxy = new TaskanaEngineProxy(taskanaEngine); + try { + SqlSession session = engineProxy.getSqlSession(); + Configuration config = session.getConfiguration(); + if (!config.hasMapper(TaskTestMapper.class)) { + config.addMapper(TaskTestMapper.class); + } - Attachment attachment = - createExampleAttachment( - "DOCTYPE_DEFAULT", // priority 99, SL P2000D - createObjectReference( - "COMPANY_A", - "SYSTEM_B", - "INSTANCE_B", - "ArchivETI", - "12345678901234567890123456789012345678901234567890"), - "E-MAIL", - Instant.parse("2018-01-15T00:00:00Z"), - createSimpleCustomPropertyMap(3)); + TaskTestMapper mapper = session.getMapper(TaskTestMapper.class); + engineProxy.openConnection(); + List queryResult = + mapper.selectTasksByCustomAttributeLike("%Property Value of Property_1339%"); - Task task = taskService.getTask("TKI:000000000000000000000000000000000000"); - task.addAttachment(attachment); - taskService.updateTask(task); + assertThat(queryResult).hasSize(1); + Task retrievedTask = queryResult.get(0); - List results = - taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list(); - assertThat(results).hasSize(1); - assertThat(results.get(0).getAttachmentSummaries()).hasSize(3); + assertThat(retrievedTask.getId()).isEqualTo(createdTask.getId()); - assertThat(results.get(0).getAttachmentSummaries().get(0)).isNotNull(); - } + // verify that the map is correctly retrieved from the database + Map customAttributesFromDb = retrievedTask.getCustomAttributeMap(); + assertThat(customAttributesFromDb).isEqualTo(customAttributesForCreate); - @WithAccessId(user = "admin") - @TestFactory - Stream should_ReturnCorrectResults_When_QueryingForCustomXStatements() { - List> list = - List.of( - Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3), - Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1), - Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2), - Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6), - Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5), - Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3), - Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3), - Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3), - Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3), - Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88), - Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3), - Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3)); - assertThat(list).hasSameSizeAs(TaskCustomField.values()); - - return DynamicTest.stream( - list.iterator(), - t -> t.getLeft().name(), - t -> testQueryForCustomXLikeAndIn(t.getLeft(), t.getMiddle(), t.getRight())); - } - - void testQueryForCustomXLikeAndIn( - TaskCustomField customField, String[] searchArguments, int expectedResult) throws Exception { - List results = - taskService.createTaskQuery().customAttributeLike(customField, searchArguments).list(); - assertThat(results).hasSize(expectedResult); - - String[] customAttributes = - results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new); - - List result2 = - taskService.createTaskQuery().customAttributeIn(customField, customAttributes).list(); - assertThat(result2).hasSize(expectedResult); - } - - @WithAccessId(user = "admin") - @TestFactory - Stream should_ReturnCorrectResults_When_QueryingForCustomXNotIn() { - // carefully constructed to always return exactly 2 results - List> list = - List.of( - Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom1"}, 2), - Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"custom3"}, 2), - Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al", "el"}, 2), - Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"11", "vvg"}, 2), - Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2), - Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"custom10"}, 2), - Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"custom11"}, 2), - Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"custom12"}, 2), - Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"custom13"}, 2), - Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"abc"}, 2), - Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"custom15"}, 2), - Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"custom16"}, 2)); - assertThat(list).hasSameSizeAs(TaskCustomField.values()); - - return DynamicTest.stream( - list.iterator(), - t -> t.getLeft().name(), - t -> testQueryForCustomXNotIn(t.getLeft(), t.getMiddle(), t.getRight())); - } - - void testQueryForCustomXNotIn( - TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception { - long results = - taskService.createTaskQuery().customAttributeNotIn(customField, searchArguments).count(); - assertThat(results).isEqualTo(expectedCount); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForCustom7WithExceptionInLike() { - assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeLike(CUSTOM_7).list()) - .isInstanceOf(InvalidArgumentException.class); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForCustom7WithExceptionInIn() throws Exception { - List results = - taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list(); - assertThat(results).isEmpty(); - - assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeIn(CUSTOM_7).list()) - .isInstanceOf(InvalidArgumentException.class); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForCustom7WithException() throws Exception { - List results = - taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list(); - assertThat(results).hasSize(2); - - String[] ids = results.stream().map(t -> t.getCustomAttribute(CUSTOM_7)).toArray(String[]::new); - - List result2 = - taskService.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list(); - assertThat(result2).hasSize(2); - } - - @WithAccessId(user = "admin") - @Test - void testQueryTaskByCustomAttributes() throws Exception { - Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A"); - newTask.setPrimaryObjRef( - createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); - newTask.setClassificationKey("T2100"); - Map customAttributesForCreate = - createSimpleCustomPropertyMap(20000); // about 1 Meg - newTask.setCustomAttributeMap(customAttributesForCreate); - Task createdTask = taskService.createTask(newTask); - - assertThat(createdTask).isNotNull(); - // query the task by custom attributes - TaskanaEngineProxy engineProxy = new TaskanaEngineProxy(taskanaEngine); - try { - SqlSession session = engineProxy.getSqlSession(); - Configuration config = session.getConfiguration(); - if (!config.hasMapper(TaskTestMapper.class)) { - config.addMapper(TaskTestMapper.class); + } finally { + engineProxy.returnConnection(); } - - TaskTestMapper mapper = session.getMapper(TaskTestMapper.class); - engineProxy.openConnection(); - List queryResult = - mapper.selectTasksByCustomAttributeLike("%Property Value of Property_1339%"); - - assertThat(queryResult).hasSize(1); - Task retrievedTask = queryResult.get(0); - - assertThat(retrievedTask.getId()).isEqualTo(createdTask.getId()); - - // verify that the map is correctly retrieved from the database - Map customAttributesFromDb = retrievedTask.getCustomAttributeMap(); - assertThat(customAttributesFromDb).isEqualTo(customAttributesForCreate); - - } finally { - engineProxy.returnConnection(); } } - - @WithAccessId(user = "admin") - @Test - void should_QueryAndCountMatch_When_CalledWithSameQuery() { - TaskQuery taskQuery = taskService.createTaskQuery(); - List tasks = taskQuery.nameIn("Task99", "Task01", "Widerruf").list(); - long numberOfTasks = taskQuery.nameIn("Task99", "Task01", "Widerruf").count(); - assertThat(tasks).hasSize((int) numberOfTasks); - } - - @WithAccessId(user = "admin") - @Test - void testQueryAllPaged() { - TaskQuery taskQuery = taskService.createTaskQuery(); - long numberOfTasks = taskQuery.count(); - assertThat(numberOfTasks).isEqualTo(88); - List tasks = taskQuery.orderByDue(DESCENDING).list(); - assertThat(tasks).hasSize(88); - List tasksp = taskQuery.orderByDue(DESCENDING).listPage(4, 5); - assertThat(tasksp).hasSize(5); - tasksp = taskQuery.orderByDue(DESCENDING).listPage(5, 5); - assertThat(tasksp).hasSize(5); - } - - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForReceivedWithUpperBoundTimeInterval() { - List results = - taskService - .createTaskQuery() - .receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z"))) - .list(); - long resultCount = - taskService - .createTaskQuery() - .receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z"))) - .count(); - assertThat(results).hasSize(22); - assertThat(resultCount).isEqualTo(22); - } - - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForReceivedWithLowerBoundTimeInterval() { - List results = - taskService - .createTaskQuery() - .receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null)) - .list(); - long resultCount = - taskService - .createTaskQuery() - .receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null)) - .count(); - assertThat(results).hasSize(41); - assertThat(resultCount).isEqualTo(41); - } - - @WithAccessId(user = "admin") - @Test - void should_ReturnCorrectResults_When_QueryingForReceivedWithMultipleTimeIntervals() { - long resultCount = - taskService - .createTaskQuery() - .receivedWithin( - new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z")), - new TimeInterval(Instant.parse("2018-01-29T15:55:22Z"), null)) - .count(); - - long resultCount2 = - taskService - .createTaskQuery() - .receivedWithin( - new TimeInterval( - Instant.parse("2018-01-29T15:55:25Z"), Instant.parse("2018-01-29T15:55:30Z")), - new TimeInterval( - Instant.parse("2018-01-29T15:55:18Z"), Instant.parse("2018-01-29T15:55:21Z"))) - .count(); - assertThat(resultCount).isEqualTo(61); - assertThat(resultCount2).isEqualTo(4); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForCreatorIn() { - List results = - taskService.createTaskQuery().creatorIn("creator_user_id2", "creator_user_id3").list(); - assertThat(results).hasSize(4); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForCreatorLike() { - List results = taskService.createTaskQuery().creatorLike("ersTeLlEr%").list(); - assertThat(results).hasSize(3); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForNoteLike() { - List results = taskService.createTaskQuery().noteLike("Some%").list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForClassificationCategoryIn() { - List results = - taskService.createTaskQuery().classificationCategoryIn("MANUAL", "AUTOMATIC").list(); - assertThat(results).hasSize(4); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForClassificationCategoryLike() { - List results = - taskService.createTaskQuery().classificationCategoryLike("AUTO%").list(); - assertThat(results).hasSize(1); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForPrimaryObjectReferenceCompanyLike() { - List results = - taskService.createTaskQuery().primaryObjectReferenceCompanyLike("My%").list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForPrimaryObjectReferenceSystemLike() { - List results = - taskService.createTaskQuery().primaryObjectReferenceSystemLike("My%").list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForPrimaryObjectReferenceSystemInstanceLike() { - List results = - taskService.createTaskQuery().primaryObjectReferenceSystemInstanceLike("My%").list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForPrimaryObjectReferenceTypeLike() { - List results = - taskService.createTaskQuery().primaryObjectReferenceTypeLike("My%").list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForReadEquals() { - List results = taskService.createTaskQuery().readEquals(true).list(); - assertThat(results).hasSize(39); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForTransferredEquals() { - List results = taskService.createTaskQuery().transferredEquals(true).list(); - assertThat(results).hasSize(2); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForBusinessProcessIdIn() { - List results = - taskService.createTaskQuery().businessProcessIdIn("PI_0000000000003", "BPI21").list(); - assertThat(results).hasSize(9); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentClassificationKeyIn() { - List results = - taskService.createTaskQuery().attachmentClassificationKeyIn("L110102").list(); - assertThat(results).hasSize(1); - assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000002"); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentClassificationKeyLike() { - List results = - taskService.createTaskQuery().attachmentClassificationKeyLike("%10102").list(); - assertThat(results).hasSize(1); - assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000002"); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentClassificationIdIn() { - List results = - taskService - .createTaskQuery() - .attachmentClassificationIdIn("CLI:100000000000000000000000000000000002") - .list(); - assertThat(results).hasSize(2); - assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000001"); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentChannelLike() { - List results = taskService.createTaskQuery().attachmentChannelLike("%6").list(); - assertThat(results).hasSize(2); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentReferenceIn() { - List results = - taskService.createTaskQuery().attachmentReferenceValueIn("val4").list(); - assertThat(results).hasSize(6); - assertThat(results.get(5).getAttachmentSummaries()).hasSize(1); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentReceivedIn() { - TimeInterval interval = - new TimeInterval(getInstant("2018-01-30T12:00:00"), getInstant("2018-01-31T12:00:00")); - List results = - taskService - .createTaskQuery() - .attachmentReceivedWithin(interval) - .orderByWorkbasketId(DESCENDING) - .list(); - assertThat(results).hasSize(2); - assertThat(results.get(0).getId()).isEqualTo("TKI:000000000000000000000000000000000001"); - assertThat(results.get(1).getId()).isEqualTo("TKI:000000000000000000000000000000000011"); - } - - @WithAccessId(user = "admin") - @Test - void should_ReturnOrderedResult_When_OrderByCreatorDescIsSet() { - List results = taskService.createTaskQuery().orderByCreator(DESCENDING).list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(TaskSummary::getCreator) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @Test - void should_ReturnOrderedResult_When_OrderByWorkbasketIdDescIsSet() { - List results = - taskService.createTaskQuery().orderByWorkbasketId(DESCENDING).list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(TaskSummary::getWorkbasketSummary) - .extracting(WorkbasketSummary::getId) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @TestFactory - Stream should_ReturnOrderedResult_When_OrderByCustomXAscIsSet() { - Iterator iterator = Arrays.stream(TaskCustomField.values()).iterator(); - return DynamicTest.stream( - iterator, - s -> String.format("order by %s asc", s), - s -> should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet(s, ASCENDING)); - } - - @WithAccessId(user = "admin") - @TestFactory - Stream should_ReturnOrderedResult_When_OrderByCustomXDescIsSet() { - Iterator iterator = Arrays.stream(TaskCustomField.values()).iterator(); - - return DynamicTest.stream( - iterator, - s -> String.format("order by %s desc", s), - s -> should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet(s, DESCENDING)); - } - - void should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet( - TaskCustomField customField, SortDirection sortDirection) { - List results = - taskService.createTaskQuery().orderByCustomAttribute(customField, sortDirection).list(); - - Comparator comparator = - sortDirection == ASCENDING ? CASE_INSENSITIVE_ORDER : CASE_INSENSITIVE_ORDER.reversed(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(t -> t.getCustomAttribute(customField)) - .filteredOn(Objects::nonNull) - .isSortedAccordingTo(comparator); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderWithDirectionNull() { - List results = - taskService.createTaskQuery().orderByPrimaryObjectReferenceSystemInstance(null).list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(TaskSummary::getPrimaryObjRef) - .extracting(ObjectReference::getSystemInstance) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentClassificationIdAsc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentClassificationId(ASCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getClassificationSummary) - .extracting(ClassificationSummary::getId) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentClassificationIdDesc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentClassificationId(DESCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getClassificationSummary) - .extracting(ClassificationSummary::getId) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentClassificationKeyAsc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentClassificationKey(ASCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getClassificationSummary) - .extracting(ClassificationSummary::getKey) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentClassificationKeyDesc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentClassificationKey(DESCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getClassificationSummary) - .extracting(ClassificationSummary::getKey) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentRefValueDesc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentReference(DESCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getObjectReference) - .extracting(ObjectReference::getValue) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentReceivedAsc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000008", - "TKI:000000000000000000000000000000000052", - "TKI:000000000000000000000000000000000054") - .orderByAttachmentReceived(ASCENDING) - .list(); - - assertThat(results) - .hasSize(3) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getReceived) - .isSorted(); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentReceivedDesc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000008", - "TKI:000000000000000000000000000000000052", - "TKI:000000000000000000000000000000000054") - .orderByAttachmentReceived(DESCENDING) - .list(); - - assertThat(results) - .hasSize(3) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .extracting(AttachmentSummary::getReceived) - .isSortedAccordingTo(Comparator.naturalOrder().reversed()); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForOrderByAttachmentChannelAscAndReferenceDesc() { - List results = - taskService - .createTaskQuery() - .idIn( - "TKI:000000000000000000000000000000000009", - "TKI:000000000000000000000000000000000010", - "TKI:000000000000000000000000000000000011", - "TKI:000000000000000000000000000000000012") - .orderByAttachmentChannel(ASCENDING) - .orderByAttachmentReference(DESCENDING) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .flatExtracting(TaskSummary::getAttachmentSummaries) - .isSortedAccordingTo( - Comparator.comparing(AttachmentSummary::getChannel, CASE_INSENSITIVE_ORDER) - .thenComparing( - a -> a.getObjectReference().getValue(), CASE_INSENSITIVE_ORDER.reversed())); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForAttachmentChannelLikeAndOrdering() { - List results = - taskService - .createTaskQuery() - .attachmentChannelLike("CH%") - .orderByClassificationKey(DESCENDING) - .list(); - - assertThat(results) - .extracting(TaskSummary::getClassificationSummary) - .extracting(ClassificationSummary::getKey) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - - results = - taskService - .createTaskQuery() - .attachmentChannelLike("CH%") - .orderByClassificationKey(ASCENDING) - .list(); - - assertThat(results) - .extracting(TaskSummary::getClassificationSummary) - .extracting(ClassificationSummary::getKey) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); - } - - @WithAccessId(user = "admin") - @Test - void testQueryForExternalIdIn() { - - List results = - taskService - .createTaskQuery() - .externalIdIn( - "ETI:000000000000000000000000000000000010", - "ETI:000000000000000000000000000000000011", - "ETI:000000000000000000000000000000000012", - "ETI:000000000000000000000000000000000013", - "ETI:000000000000000000000000000000000014", - "ETI:000000000000000000000000000000000015", - "ETI:000000000000000000000000000000000016", - "ETI:000000000000000000000000000000000017", - "ETI:000000000000000000000000000000000018", - "ETI:000000000000000000000000000000000019") - .list(); - assertThat(results).hasSize(10); - - String[] ids = results.stream().map(TaskSummary::getId).toArray(String[]::new); - - List result2 = taskService.createTaskQuery().idIn(ids).list(); - assertThat(result2).hasSize(10); - } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java deleted file mode 100644 index b8e242fa6..000000000 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java +++ /dev/null @@ -1,138 +0,0 @@ -package acceptance.task; - -import static org.assertj.core.api.Assertions.assertThat; - -import acceptance.AbstractAccTest; -import java.util.List; -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.models.ObjectReference; -import pro.taskana.task.api.models.TaskSummary; - -/** Acceptance test for all "query tasks by object reference" scenarios. */ -@ExtendWith(JaasExtension.class) -class QueryTasksByObjectReferenceAccTest extends AbstractAccTest { - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferenceFilter_When_ExactValueIsSet() { - List results = - taskService.createTaskQuery().primaryObjectReferenceValueIn("11223344", "22334455").list(); - assertThat(results).hasSize(33); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_ValueIsSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setValue("11223344"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(21); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_TypeIsSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setType("SDNR"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(46); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_CompanyIsSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setCompany("MyCompany1"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_SystemIsSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setSystem("MySystem1"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_SystemInstanceIsSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setSystemInstance("MyInstance1"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(7); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_MultipleObjectReferencesExist() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setType("SDNR"); - ObjectReference objectReference1 = new ObjectReference(); - objectReference1.setValue("11223344"); - List results = - taskService - .createTaskQuery() - .primaryObjectReferenceIn(objectReference, objectReference1) - .list(); - assertThat(results).hasSize(57); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferencesFilter_When_MultipleFieldsAreSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setCompany("00"); - objectReference.setSystem("PASyste2"); - objectReference.setSystemInstance("00"); - objectReference.setType("VNR"); - objectReference.setValue("67890123"); - List results = - taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).list(); - assertThat(results).hasSize(1); - } - - @WithAccessId(user = "admin") - @Test - void should_CountWithObjectReferencesFilter_When_MultipleFieldsAreSet() { - ObjectReference objectReference = new ObjectReference(); - objectReference.setCompany("00"); - objectReference.setSystem("PASyste2"); - objectReference.setSystemInstance("00"); - objectReference.setType("VNR"); - objectReference.setValue("67890123"); - long count = taskService.createTaskQuery().primaryObjectReferenceIn(objectReference).count(); - assertThat(count).isEqualTo(1); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferenceFilter_When_ExactValueAndTypeAreSet() { - List results = - taskService - .createTaskQuery() - .primaryObjectReferenceTypeIn("SDNR") - .primaryObjectReferenceValueIn("11223344") - .list(); - assertThat(results).hasSize(10); - } - - @WithAccessId(user = "admin") - @Test - void should_ApplyObjectReferenceFilter_When_ValueLikeIsSet() { - List results = - taskService.createTaskQuery().primaryObjectReferenceValueLike("%567%").list(); - assertThat(results).hasSize(10); - } -} diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByRoleAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByRoleAccTest.java index 04e1652cb..571c11ffb 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByRoleAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByRoleAccTest.java @@ -4,6 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat; import acceptance.AbstractAccTest; import java.util.List; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.TestTemplate; import org.junit.jupiter.api.extension.ExtendWith; @@ -18,48 +19,53 @@ import pro.taskana.task.api.models.TaskSummary; @ExtendWith(JaasExtension.class) class QueryTasksByRoleAccTest extends AbstractAccTest { - @Test - void should_ReturnNoResult_When_UserIsNotAuthenticated() { - TaskService taskService = taskanaEngine.getTaskService(); + @Nested + class RoleTest { - List results = taskService.createTaskQuery().list(); + @Test + void should_ReturnNoResult_When_UserIsNotAuthenticated() { + TaskService taskService = taskanaEngine.getTaskService(); - assertThat(results).isEmpty(); - } + List results = taskService.createTaskQuery().list(); - @WithAccessId(user = "admin") - @WithAccessId(user = "taskadmin") - @WithAccessId(user = "businessadmin") - @WithAccessId(user = "monitor") - @WithAccessId(user = "teamlead-1") - @WithAccessId(user = "user-1-1") - @TestTemplate - void should_FindAllAccessibleTasksDependentOnTheUser_When_MakingTaskQuery() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = taskService.createTaskQuery().list(); - - int expectedSize; - - switch (taskanaEngine.getCurrentUserContext().getUserid()) { - case "admin": - case "taskadmin": - expectedSize = 88; - break; - case "businessadmin": - case "monitor": - expectedSize = 0; - break; - case "teamlead-1": - expectedSize = 26; - break; - case "user-1-1": - expectedSize = 7; - break; - default: - throw new SystemException( - String.format("Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid())); + assertThat(results).isEmpty(); } - assertThat(results).hasSize(expectedSize); + @WithAccessId(user = "admin") + @WithAccessId(user = "taskadmin") + @WithAccessId(user = "businessadmin") + @WithAccessId(user = "monitor") + @WithAccessId(user = "teamlead-1") + @WithAccessId(user = "user-1-1") + @TestTemplate + void should_FindAllAccessibleTasksDependentOnTheUser_When_MakingTaskQuery() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = taskService.createTaskQuery().list(); + + int expectedSize; + + switch (taskanaEngine.getCurrentUserContext().getUserid()) { + case "admin": + case "taskadmin": + expectedSize = 88; + break; + case "businessadmin": + case "monitor": + expectedSize = 0; + break; + case "teamlead-1": + expectedSize = 26; + break; + case "user-1-1": + expectedSize = 7; + break; + default: + throw new SystemException( + String.format( + "Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid())); + } + + assertThat(results).hasSize(expectedSize); + } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByTimeIntervalsAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByTimeIntervalsAccTest.java index 10a947685..cf0158315 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByTimeIntervalsAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByTimeIntervalsAccTest.java @@ -5,7 +5,10 @@ import static org.assertj.core.api.Assertions.assertThat; import acceptance.AbstractAccTest; import java.time.Instant; import java.util.List; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import pro.taskana.common.api.BaseQuery.SortDirection; @@ -18,208 +21,281 @@ import pro.taskana.task.api.models.TaskSummary; /** Acceptance test for all "query tasks with sorting" scenarios. */ @ExtendWith(JaasExtension.class) class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest { - private static SortDirection asc = SortDirection.ASCENDING; QueryTasksByTimeIntervalsAccTest() { super(); } - @WithAccessId(user = "admin") - @Test - void testCreatedWithin2Intervals() { - TaskService taskService = taskanaEngine.getTaskService(); + @Nested + class TimeIntervalTest { - TimeInterval interval1 = - new TimeInterval(getInstant("2018-01-29T15:55:10"), getInstant("2018-01-29T15:55:17")); - TimeInterval interval2 = - new TimeInterval(getInstant("2018-01-29T15:55:23"), getInstant("2018-01-29T15:55:25")); + @WithAccessId(user = "admin") + @Test + void testCreatedWithin2Intervals() { + TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .createdWithin(interval1, interval2) - .orderByCreated(asc) - .list(); + TimeInterval interval1 = + new TimeInterval(getInstant("2018-01-29T15:55:10"), getInstant("2018-01-29T15:55:17")); + TimeInterval interval2 = + new TimeInterval(getInstant("2018-01-29T15:55:23"), getInstant("2018-01-29T15:55:25")); - assertThat(results).hasSize(53); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getCreated(); - assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue(); + List results = + taskService + .createTaskQuery() + .createdWithin(interval1, interval2) + .orderByCreated(asc) + .list(); - if (previousSummary != null) { - assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + assertThat(results).hasSize(53); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getCreated(); + assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue(); + + if (previousSummary != null) { + assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testCreatedBefore() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testCreatedBefore() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval1 = new TimeInterval(null, getInstant("2018-01-29T15:55:17")); + TimeInterval interval1 = new TimeInterval(null, getInstant("2018-01-29T15:55:17")); - List results = - taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list(); + List results = + taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list(); - assertThat(results).hasSize(38); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getCreated(); - assertThat(interval1.contains(cr)).isTrue(); + assertThat(results).hasSize(38); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getCreated(); + assertThat(interval1.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testCreatedAfter() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testCreatedAfter() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval1 = new TimeInterval(getInstant("2018-01-29T15:55:17"), null); + TimeInterval interval1 = new TimeInterval(getInstant("2018-01-29T15:55:17"), null); - List results = - taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list(); + List results = + taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list(); - assertThat(results).hasSize(52); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getCreated(); - assertThat(interval1.contains(cr)).isTrue(); + assertThat(results).hasSize(52); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getCreated(); + assertThat(interval1.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testClaimedWithin2Intervals() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testClaimedWithin2Intervals() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval1 = - new TimeInterval(getInstant("2018-01-30T15:55:00"), getInstant("2018-01-30T15:55:10")); - TimeInterval interval2 = - new TimeInterval(getInstant("2018-01-30T15:55:23"), getInstant("2018-01-30T15:55:25")); + TimeInterval interval1 = + new TimeInterval(getInstant("2018-01-30T15:55:00"), getInstant("2018-01-30T15:55:10")); + TimeInterval interval2 = + new TimeInterval(getInstant("2018-01-30T15:55:23"), getInstant("2018-01-30T15:55:25")); - List results = - taskService - .createTaskQuery() - .claimedWithin(interval1, interval2) - .orderByCreated(asc) - .list(); + List results = + taskService + .createTaskQuery() + .claimedWithin(interval1, interval2) + .orderByCreated(asc) + .list(); - assertThat(results).hasSize(38); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getClaimed(); - assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue(); + assertThat(results).hasSize(38); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getClaimed(); + assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getClaimed().isAfter(taskSummary.getClaimed())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getClaimed().isAfter(taskSummary.getClaimed())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testCompletedWithin() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testCompletedWithin() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval = - new TimeInterval(getInstant("2018-01-30T16:55:23"), getInstant("2018-01-30T16:55:25")); - List results = - taskService.createTaskQuery().completedWithin(interval).orderByCompleted(asc).list(); + TimeInterval interval = + new TimeInterval(getInstant("2018-01-30T16:55:23"), getInstant("2018-01-30T16:55:25")); + List results = + taskService.createTaskQuery().completedWithin(interval).orderByCompleted(asc).list(); - assertThat(results).hasSize(18); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getCompleted(); - assertThat(interval.contains(cr)).isTrue(); + assertThat(results).hasSize(18); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getCompleted(); + assertThat(interval.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getCompleted().isAfter(taskSummary.getCompleted())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getCompleted().isAfter(taskSummary.getCompleted())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testModifiedWithin() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testModifiedWithin() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval = - new TimeInterval(getInstant("2018-01-30T15:55:00"), getInstant("2018-01-30T15:55:22")); - List results = - taskService.createTaskQuery().modifiedWithin(interval).orderByModified(asc).list(); + TimeInterval interval = + new TimeInterval(getInstant("2018-01-30T15:55:00"), getInstant("2018-01-30T15:55:22")); + List results = + taskService.createTaskQuery().modifiedWithin(interval).orderByModified(asc).list(); - assertThat(results).hasSize(7); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getModified(); - assertThat(interval.contains(cr)).isTrue(); + assertThat(results).hasSize(7); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getModified(); + assertThat(interval.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getModified().isAfter(taskSummary.getModified())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getModified().isAfter(taskSummary.getModified())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testPlannedWithin() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testPlannedWithin() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval = - new TimeInterval(getInstant("2018-01-29T15:55:00"), getInstant("2018-01-30T15:55:22")); - List results = - taskService.createTaskQuery().plannedWithin(interval).orderByPlanned(asc).list(); + TimeInterval interval = + new TimeInterval(getInstant("2018-01-29T15:55:00"), getInstant("2018-01-30T15:55:22")); + List results = + taskService.createTaskQuery().plannedWithin(interval).orderByPlanned(asc).list(); - assertThat(results).hasSize(85); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getPlanned(); - assertThat(interval.contains(cr)).isTrue(); + assertThat(results).hasSize(85); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getPlanned(); + assertThat(interval.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse(); + } + previousSummary = taskSummary; } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testDueWithin() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "admin") + @Test + void testDueWithin() { + TaskService taskService = taskanaEngine.getTaskService(); - TimeInterval interval = - new TimeInterval(getInstant("2018-01-29T15:55:00"), getInstant("2018-01-30T15:55:22")); - List results = - taskService.createTaskQuery().dueWithin(interval).orderByPlanned(asc).list(); + TimeInterval interval = + new TimeInterval(getInstant("2018-01-29T15:55:00"), getInstant("2018-01-30T15:55:22")); + List results = + taskService.createTaskQuery().dueWithin(interval).orderByPlanned(asc).list(); - assertThat(results).hasSize(85); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - Instant cr = taskSummary.getDue(); - assertThat(interval.contains(cr)).isTrue(); + assertThat(results).hasSize(85); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + Instant cr = taskSummary.getDue(); + assertThat(interval.contains(cr)).isTrue(); - if (previousSummary != null) { - assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse(); + if (previousSummary != null) { + assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse(); + } + previousSummary = taskSummary; + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class Received { + @WithAccessId(user = "admin") + @Test + void should_ReturnCorrectResults_When_QueryingForReceivedWithUpperBoundTimeInterval() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z"))) + .list(); + long resultCount = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin(new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z"))) + .count(); + assertThat(results).hasSize(22); + assertThat(resultCount).isEqualTo(22); + } + + @WithAccessId(user = "admin") + @Test + void should_ReturnCorrectResults_When_QueryingForReceivedWithLowerBoundTimeInterval() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null)) + .list(); + long resultCount = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin(new TimeInterval(Instant.parse("2018-01-29T15:55:20Z"), null)) + .count(); + assertThat(results).hasSize(41); + assertThat(resultCount).isEqualTo(41); + } + + @WithAccessId(user = "admin") + @Test + void should_ReturnCorrectResults_When_QueryingForReceivedWithMultipleTimeIntervals() { + long resultCount = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin( + new TimeInterval(null, Instant.parse("2018-01-29T15:55:20Z")), + new TimeInterval(Instant.parse("2018-01-29T15:55:22Z"), null)) + .count(); + + long resultCount2 = + taskanaEngine + .getTaskService() + .createTaskQuery() + .receivedWithin( + new TimeInterval( + Instant.parse("2018-01-29T15:55:25Z"), + Instant.parse("2018-01-29T15:55:30Z")), + new TimeInterval( + Instant.parse("2018-01-29T15:55:18Z"), + Instant.parse("2018-01-29T15:55:21Z"))) + .count(); + assertThat(resultCount).isEqualTo(61); + assertThat(resultCount2).isEqualTo(4); } - previousSummary = taskSummary; } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java index 550b016b7..ed4f707bd 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java @@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy; import acceptance.AbstractAccTest; import java.util.List; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -18,88 +19,112 @@ import pro.taskana.task.api.models.TaskSummary; @ExtendWith(JaasExtension.class) class QueryTasksByWildcardSearchAccTest extends AbstractAccTest { - @WithAccessId(user = "admin") - @Test - void should_ReturnAllTasksByWildcardSearch_For_ProvidedSearchValue() { - WildcardSearchField[] wildcards = { - WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME - }; + @Nested + class WildcardSearchTest { - List foundTasks = - taskService - .createTaskQuery() - .wildcardSearchFieldsIn(wildcards) - .wildcardSearchValueLike("%99%") - .orderByName(SortDirection.ASCENDING) - .list(); + @WithAccessId(user = "admin") + @Test + void should_ReturnAllTasksByWildcardSearch_For_ProvidedSearchValue() { + WildcardSearchField[] wildcards = { + WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME + }; - assertThat(foundTasks).hasSize(4); - } + List foundTasks = + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn(wildcards) + .wildcardSearchValueLike("%99%") + .orderByName(SortDirection.ASCENDING) + .list(); - @WithAccessId(user = "admin") - @Test - void should_CountAllTasksByWildcardSearch_For_ProvidedSearchValue() { - WildcardSearchField[] wildcards = { - WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME - }; + assertThat(foundTasks).hasSize(4); + } - long foundTasks = - taskService - .createTaskQuery() - .wildcardSearchFieldsIn(wildcards) - .wildcardSearchValueLike("%99%") - .orderByName(SortDirection.ASCENDING) - .count(); + @WithAccessId(user = "admin") + @Test + void should_CountAllTasksByWildcardSearch_For_ProvidedSearchValue() { + WildcardSearchField[] wildcards = { + WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME + }; - assertThat(foundTasks).isEqualTo(4); - } + long foundTasks = + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn(wildcards) + .wildcardSearchValueLike("%99%") + .orderByName(SortDirection.ASCENDING) + .count(); - @WithAccessId(user = "admin") - @Test - void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() { - WildcardSearchField[] wildcards = {WildcardSearchField.NAME}; + assertThat(foundTasks).isEqualTo(4); + } - List foundTasksCaseSensitive = - taskService - .createTaskQuery() - .wildcardSearchFieldsIn(wildcards) - .wildcardSearchValueLike("%Wid%") - .list(); + @WithAccessId(user = "admin") + @Test + void should_ReturnAllTasks_For_ProvidedSearchValueAndAdditionalParameters() { + WildcardSearchField[] wildcards = { + WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME + }; - List foundTasksCaseInsensitive = - taskService - .createTaskQuery() - .wildcardSearchFieldsIn(wildcards) - .wildcardSearchValueLike("%wid%") - .list(); + List foundTasks = + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn(wildcards) + .wildcardSearchValueLike("%99%") + .ownerIn("user-1-1") + .businessProcessIdLike("%PI2%") + .orderByName(SortDirection.ASCENDING) + .list(); - assertThat(foundTasksCaseSensitive).hasSize(81); - assertThat(foundTasksCaseInsensitive).containsExactlyElementsOf(foundTasksCaseSensitive); - } + assertThat(foundTasks).hasSize(1); + } - @WithAccessId(user = "admin") - @Test - void should_ThrowException_When_NotUsingSearchFieldsAndValueParamsTogether() { + @WithAccessId(user = "admin") + @Test + void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() { + WildcardSearchField[] wildcards = {WildcardSearchField.NAME}; - ThrowingCallable queryAttempt = - () -> - taskService - .createTaskQuery() - .wildcardSearchValueLike("%99%") - .orderByName(SortDirection.ASCENDING) - .list(); + List foundTasksCaseSensitive = + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn(wildcards) + .wildcardSearchValueLike("%Wid%") + .list(); - assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class); + List foundTasksCaseInsensitive = + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn(wildcards) + .wildcardSearchValueLike("%wid%") + .list(); - queryAttempt = - () -> - taskService - .createTaskQuery() - .wildcardSearchFieldsIn( - WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION) - .orderByName(SortDirection.ASCENDING) - .list(); + assertThat(foundTasksCaseSensitive).hasSize(81); + assertThat(foundTasksCaseInsensitive).containsExactlyElementsOf(foundTasksCaseSensitive); + } - assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class); + @WithAccessId(user = "admin") + @Test + void should_ThrowException_When_NotUsingSearchFieldsAndValueParamsTogether() { + + ThrowingCallable queryAttempt = + () -> + TASK_SERVICE + .createTaskQuery() + .wildcardSearchValueLike("%99%") + .orderByName(SortDirection.ASCENDING) + .list(); + + assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class); + + queryAttempt = + () -> + TASK_SERVICE + .createTaskQuery() + .wildcardSearchFieldsIn( + WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION) + .orderByName(SortDirection.ASCENDING) + .list(); + + assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class); + } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWorkbasketAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWorkbasketAccTest.java index d224a8423..66f421569 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWorkbasketAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWorkbasketAccTest.java @@ -1,75 +1,54 @@ package acceptance.task; -import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import acceptance.AbstractAccTest; -import java.util.List; import org.assertj.core.api.ThrowableAssert.ThrowingCallable; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import pro.taskana.common.api.KeyDomain; 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.models.TaskSummary; import pro.taskana.workbasket.api.exceptions.NotAuthorizedToQueryWorkbasketException; /** Acceptance test for all "query tasks by workbasket" scenarios. */ @ExtendWith(JaasExtension.class) class QueryTasksByWorkbasketAccTest extends AbstractAccTest { - QueryTasksByWorkbasketAccTest() { - super(); - } + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class WorkbasketTest { + @WithAccessId(user = "user-1-1") + @Test + void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() { + TaskService taskService = taskanaEngine.getTaskService(); - @WithAccessId(user = "user-1-2", groups = GROUP_2_DN) - @Test - void testQueryForWorkbasketKeyDomain() { - TaskService taskService = taskanaEngine.getTaskService(); - List workbasketIdentifiers = - List.of(new KeyDomain("GPK_KSC_2", "DOMAIN_A"), new KeyDomain("USER-1-2", "DOMAIN_A")); + ThrowingCallable call = + () -> + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("USER-2-1", "DOMAIN_A")) + .list(); + assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class); + } - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(workbasketIdentifiers.toArray(new KeyDomain[0])) - .list(); - assertThat(results).hasSize(30); - - String[] ids = - results.stream().map(t -> t.getWorkbasketSummary().getId()).toArray(String[]::new); - - List result2 = taskService.createTaskQuery().workbasketIdIn(ids).list(); - assertThat(result2).hasSize(30); - } - - @WithAccessId(user = "user-1-1") - @Test - void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() { - TaskService taskService = taskanaEngine.getTaskService(); - - ThrowingCallable call = - () -> - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-2-1", "DOMAIN_A")) - .list(); - assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class); - } - - @WithAccessId(user = "user-1-1") - @Test - void testThrowsExceptionIfNoOpenerPermissionOnAtLeastOneQueriedWorkbasket() { - TaskService taskService = taskanaEngine.getTaskService(); - ThrowingCallable call = - () -> - taskService - .createTaskQuery() - .workbasketKeyDomainIn( - new KeyDomain("USER-1-1", "DOMAIN_A"), new KeyDomain("USER-2-1", "DOMAIN_A")) - .list(); - assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class); + @WithAccessId(user = "user-1-1") + @Test + void testThrowsExceptionIfNoOpenerPermissionOnAtLeastOneQueriedWorkbasket() { + TaskService taskService = taskanaEngine.getTaskService(); + ThrowingCallable call = + () -> + taskService + .createTaskQuery() + .workbasketKeyDomainIn( + new KeyDomain("USER-1-1", "DOMAIN_A"), new KeyDomain("USER-2-1", "DOMAIN_A")) + .list(); + assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class); + } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java index b4a2bcdb9..277b6cb66 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java @@ -14,7 +14,11 @@ import acceptance.AbstractAccTest; import java.util.Arrays; import java.util.List; import org.assertj.core.api.SoftAssertions; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import pro.taskana.common.api.BaseQuery.SortDirection; @@ -22,102 +26,148 @@ import pro.taskana.common.api.KeyDomain; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; import pro.taskana.task.api.TaskQueryColumnName; +import pro.taskana.task.api.TaskService; +import pro.taskana.task.internal.TaskServiceImpl; /** Acceptance test for listing the column values within a workbasket. */ @ExtendWith(JaasExtension.class) class QueryTasksListValuesAccTest extends AbstractAccTest { - @WithAccessId(user = "admin") - @Test - void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() { - SoftAssertions softly = new SoftAssertions(); - Arrays.stream(TaskQueryColumnName.values()) - .forEach( - columnName -> - softly - .assertThatCode( - () -> taskService.createTaskQuery().listValues(columnName, ASCENDING)) - .describedAs("Column is not working " + columnName) - .doesNotThrowAnyException()); - softly.assertAll(); - } + private static final TaskServiceImpl TASK_SERVICE = + (TaskServiceImpl) taskanaEngine.getTaskService(); - @WithAccessId(user = "admin") - @Test - void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() { - List columnValueList = - taskService - .createTaskQuery() - .ownerLike("%user%") - .orderByOwner(DESCENDING) - .listValues(OWNER, null); - assertThat(columnValueList).hasSize(3); - } + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class ListValuesTest { - @WithAccessId(user = "admin") - @Test - void should_ReturnStateValues_When_ListValuesForStateIsInvoked() { - List columnValueList = taskService.createTaskQuery().listValues(STATE, null); - assertThat(columnValueList).hasSize(5); - } + @WithAccessId(user = "admin") + @Test + void testQueryTaskValuesForAttachmentClassificationName() { + TaskService taskService = taskanaEngine.getTaskService(); + List columnValueList = + taskService + .createTaskQuery() + .ownerLike("%user%") + .orderByOwner(DESCENDING) + .listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, null); + assertThat(columnValueList).hasSize(8); + } - @WithAccessId(user = "admin") - @Test - void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() { - List columnValueList = - taskService - .createTaskQuery() - .attachmentReferenceValueIn("val4") - .listValues(A_CHANNEL, null); - assertThat(columnValueList).hasSize(2); + @WithAccessId(user = "admin") + @Test + void testQueryTaskValuesForClassificationName() { + TaskService taskService = taskanaEngine.getTaskService(); + List columnValueList = + taskService + .createTaskQuery() + .ownerLike("%user%") + .orderByClassificationName(ASCENDING) + .listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null); + assertThat(columnValueList).hasSize(5); + } - columnValueList = - taskService - .createTaskQuery() - .attachmentReferenceValueLike("%") - .listValues(A_REF_VALUE, null); - assertThat(columnValueList).hasSize(6); + @WithAccessId(user = "admin") + @Test + void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() { + SoftAssertions softly = new SoftAssertions(); + Arrays.stream(TaskQueryColumnName.values()) + .forEach( + columnName -> + softly + .assertThatCode( + () -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING)) + .describedAs("Column is not working " + columnName) + .doesNotThrowAnyException()); + softly.assertAll(); + } - columnValueList = - taskService - .createTaskQuery() - .orderByAttachmentClassificationId(DESCENDING) - .listValues(A_CLASSIFICATION_ID, null); - assertThat(columnValueList).hasSize(11); + @WithAccessId(user = "admin") + @Test + void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() { + List columnValueList = + TASK_SERVICE + .createTaskQuery() + .ownerLike("%user%") + .orderByOwner(DESCENDING) + .listValues(OWNER, null); + assertThat(columnValueList).hasSize(3); + } - columnValueList = - taskService - .createTaskQuery() - .orderByClassificationKey(DESCENDING) - .listValues(CLASSIFICATION_KEY, null); - assertThat(columnValueList).hasSize(7); - } + @WithAccessId(user = "admin") + @Test + void should_ReturnStateValues_When_ListValuesForStateIsInvoked() { + List columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null); + assertThat(columnValueList).hasSize(5); + } - @WithAccessId(user = "teamlead-1") - @Test - void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() { - KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); - List porTypes = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(keyDomain) - .primaryObjectReferenceCompanyIn("00", "11") - .listValues(TaskQueryColumnName.POR_TYPE, SortDirection.ASCENDING); - assertThat(porTypes).containsExactly("SDNR", "VNR"); - } + @WithAccessId(user = "admin") + @Test + void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() { + List columnValueList = + TASK_SERVICE + .createTaskQuery() + .attachmentReferenceValueIn("val4") + .listValues(A_CHANNEL, null); + assertThat(columnValueList).hasSize(2); - @WithAccessId(user = "teamlead-1") - @Test - void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() { - KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); - List attachmentClassificationNames = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(keyDomain) - .listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING); - assertThat(attachmentClassificationNames) - // PostgreSQL treats null differently while sorting - .containsExactlyInAnyOrder( - null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung"); + columnValueList = + TASK_SERVICE + .createTaskQuery() + .attachmentReferenceValueLike("%") + .listValues(A_REF_VALUE, null); + assertThat(columnValueList).hasSize(6); + + columnValueList = + TASK_SERVICE + .createTaskQuery() + .orderByAttachmentClassificationId(DESCENDING) + .listValues(A_CLASSIFICATION_ID, null); + assertThat(columnValueList).hasSize(11); + + columnValueList = + TASK_SERVICE + .createTaskQuery() + .orderByClassificationKey(DESCENDING) + .listValues(CLASSIFICATION_KEY, null); + assertThat(columnValueList).hasSize(7); + } + + @Disabled() + @WithAccessId(user = "admin") + @Test + void should_ReturnAllExternalIds_When_ListValuesForExternalIdsIsInvoked() { + + List resultValues = + TASK_SERVICE.createTaskQuery().listValues(TaskQueryColumnName.EXTERNAL_ID, DESCENDING); + assertThat(resultValues).hasSize(74); + } + + @WithAccessId(user = "teamlead-1") + @Test + void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() { + KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); + List porTypes = + TASK_SERVICE + .createTaskQuery() + .workbasketKeyDomainIn(keyDomain) + .primaryObjectReferenceCompanyIn("00", "11") + .listValues(TaskQueryColumnName.POR_TYPE, SortDirection.ASCENDING); + assertThat(porTypes).containsExactly("SDNR", "VNR"); + } + + @WithAccessId(user = "teamlead-1") + @Test + void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() { + KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); + List attachmentClassificationNames = + TASK_SERVICE + .createTaskQuery() + .workbasketKeyDomainIn(keyDomain) + .listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING); + assertThat(attachmentClassificationNames) + // PostgreSQL treats null differently while sorting + .containsExactlyInAnyOrder( + null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung"); + } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithPaginationAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithPaginationAccTest.java index 66a34892b..540c58282 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithPaginationAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithPaginationAccTest.java @@ -1,15 +1,21 @@ package acceptance.task; import static org.assertj.core.api.Assertions.assertThat; +import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING; import acceptance.AbstractAccTest; import java.util.List; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; import pro.taskana.common.api.KeyDomain; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; +import pro.taskana.task.api.TaskQuery; import pro.taskana.task.api.TaskService; import pro.taskana.task.api.models.TaskSummary; @@ -17,163 +23,166 @@ import pro.taskana.task.api.models.TaskSummary; @ExtendWith(JaasExtension.class) class QueryTasksWithPaginationAccTest extends AbstractAccTest { - QueryTasksWithPaginationAccTest() { - super(); - } + @Nested + class PaginationTest { - @WithAccessId(user = "teamlead-1") - @Test - void testGetFirstPageOfTaskQueryWithOffset() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .list(0, 10); - assertThat(results).hasSize(10); - } + @WithAccessId(user = "admin") + @Test + void testQueryAllPaged() { + TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery(); + long numberOfTasks = taskQuery.count(); + assertThat(numberOfTasks).isEqualTo(88); + List tasks = taskQuery.orderByDue(DESCENDING).list(); + assertThat(tasks).hasSize(88); + List tasksp = taskQuery.orderByDue(DESCENDING).listPage(4, 5); + assertThat(tasksp).hasSize(5); + tasksp = taskQuery.orderByDue(DESCENDING).listPage(5, 5); + assertThat(tasksp).hasSize(5); + } - @WithAccessId(user = "teamlead-1") - @Test - void testSecondPageOfTaskQueryWithOffset() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .list(10, 10); - assertThat(results).hasSize(10); - } + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class OffsetAndLimit { + @WithAccessId(user = "teamlead-1") + @Test + void testGetFirstPageOfTaskQueryWithOffset() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = taskService.createTaskQuery().list(0, 10); + assertThat(results).hasSize(10); + } - @WithAccessId(user = "teamlead-1") - @Test - void testListOffsetAndLimitOutOfBounds() { - TaskService taskService = taskanaEngine.getTaskService(); + @WithAccessId(user = "teamlead-1") + @Test + void testSecondPageOfTaskQueryWithOffset() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = taskService.createTaskQuery().list(10, 10); + assertThat(results).hasSize(10); + } - // both will be 0, working - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .list(-1, -3); - assertThat(results).isEmpty(); + @WithAccessId(user = "teamlead-1") + @Test + void testListOffsetAndLimitOutOfBounds() { + TaskService taskService = taskanaEngine.getTaskService(); - // limit will be 0 - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .list(1, -3); - assertThat(results).isEmpty(); + // both will be 0, working + List results = taskService.createTaskQuery().list(-1, -3); + assertThat(results).isEmpty(); - // offset will be 0 - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .list(-1, 3); - assertThat(results).hasSize(3); - } + // limit will be 0 + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .list(1, -3); + assertThat(results).isEmpty(); - @WithAccessId(user = "teamlead-1") - @Test - void testPaginationWithPages() { - TaskService taskService = taskanaEngine.getTaskService(); + // offset will be 0 + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .list(-1, 3); + assertThat(results).hasSize(3); + } + } - // Getting full page - int pageNumber = 2; - int pageSize = 4; - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).hasSize(4); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class ListPage { + @WithAccessId(user = "teamlead-1") + @Test + void testPaginationWithPages() { + TaskService taskService = taskanaEngine.getTaskService(); - // Getting full page - pageNumber = 4; - pageSize = 1; - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).hasSize(1); + // Getting full page + int pageNumber = 2; + int pageSize = 4; + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).hasSize(4); - // Getting last results on 1 big page - pageNumber = 1; - pageSize = 100; - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).hasSize(22); + // Getting full page + pageNumber = 4; + pageSize = 1; + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).hasSize(1); - // Getting last results on multiple pages - pageNumber = 3; - pageSize = 10; - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).hasSize(2); - } + // Getting last results on 1 big page + pageNumber = 1; + pageSize = 100; + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).hasSize(22); - @WithAccessId(user = "teamlead-1") - @Test - void testPaginationNullAndNegativeLimitsIgnoring() { - TaskService taskService = taskanaEngine.getTaskService(); + // Getting last results on multiple pages + pageNumber = 3; + pageSize = 10; + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).hasSize(2); + } - // 0 limit/size = 0 results - int pageNumber = 2; - int pageSize = 0; - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).isEmpty(); + @WithAccessId(user = "teamlead-1") + @Test + void testPaginationNullAndNegativeLimitsIgnoring() { + TaskService taskService = taskanaEngine.getTaskService(); - // Negative size will be 0 = 0 results - pageNumber = 2; - pageSize = -1; - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).isEmpty(); + // 0 limit/size = 0 results + int pageNumber = 2; + int pageSize = 0; + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).isEmpty(); - // Negative page = first page - pageNumber = -1; - pageSize = 10; - results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .listPage(pageNumber, pageSize); - assertThat(results).hasSize(10); - } + // Negative size will be 0 = 0 results + pageNumber = 2; + pageSize = -1; + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).isEmpty(); - @WithAccessId(user = "teamlead-1") - @Test - void testCountOfTaskQuery() { - TaskService taskService = taskanaEngine.getTaskService(); - long count = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) - .count(); - assertThat(count).isEqualTo(22L); - } + // Negative page = first page + pageNumber = -1; + pageSize = 10; + results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A")) + .listPage(pageNumber, pageSize); + assertThat(results).hasSize(10); + } + } - @WithAccessId(user = "teamlead-1") - @Test - void testCountOfTaskQueryWithAttachmentChannelFilter() { - TaskService taskService = taskanaEngine.getTaskService(); - long count = taskService.createTaskQuery().attachmentChannelIn("ch6").count(); - assertThat(count).isEqualTo(1L); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class Count { + @Disabled() + @WithAccessId(user = "teamlead-1") + @Test + void testCountOfTaskQuery() { + TaskService taskService = taskanaEngine.getTaskService(); + long count = taskService.createTaskQuery().count(); + assertThat(count).isEqualTo(22L); + } + } } } diff --git a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java index 9f75f6511..7eb95392c 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java @@ -2,22 +2,39 @@ package acceptance.task; import static java.lang.String.CASE_INSENSITIVE_ORDER; import static org.assertj.core.api.Assertions.assertThat; +import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING; +import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING; import acceptance.AbstractAccTest; import java.time.Instant; +import java.util.Arrays; import java.util.Comparator; +import java.util.Iterator; import java.util.List; +import java.util.Objects; import java.util.stream.Collectors; +import java.util.stream.Stream; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestFactory; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; import org.junit.jupiter.api.extension.ExtendWith; +import pro.taskana.classification.api.models.ClassificationSummary; import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.api.KeyDomain; import pro.taskana.common.api.TimeInterval; import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.WithAccessId; +import pro.taskana.task.api.TaskCustomField; +import pro.taskana.task.api.TaskQueryColumnName; import pro.taskana.task.api.TaskService; import pro.taskana.task.api.TaskState; +import pro.taskana.task.api.models.AttachmentSummary; +import pro.taskana.task.api.models.ObjectReference; import pro.taskana.task.api.models.TaskSummary; import pro.taskana.workbasket.api.models.WorkbasketSummary; @@ -25,292 +42,674 @@ import pro.taskana.workbasket.api.models.WorkbasketSummary; @ExtendWith(JaasExtension.class) class QueryTasksWithSortingAccTest extends AbstractAccTest { - QueryTasksWithSortingAccTest() { - super(); - } + @Nested + class SortingTest { - @WithAccessId(user = "admin") - @Test - void testSortByModifiedAndDomain() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByModified(SortDirection.DESCENDING) - .orderByDomain(null) - .list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class TaskId { - assertThat(results).hasSize(25); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - if (previousSummary != null) { - assertThat(previousSummary.getModified().isBefore(taskSummary.getModified())).isFalse(); + @WithAccessId(user = "admin") + @Test + void should_sortByTaskIdDesc_When_TaskQueryFilterIsApplied() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService.createTaskQuery().orderByTaskId(SortDirection.DESCENDING).list(); + + // test is only valid with at least 2 results + assertThat(results).hasSizeGreaterThan(2); + + List idsDesc = + results.stream() + .map(TaskSummary::getId) + .sorted(Comparator.reverseOrder()) + .collect(Collectors.toList()); + + for (int i = 0; i < results.size(); i++) { + assertThat(results.get(i).getId()).isEqualTo(idsDesc.get(i)); + } } - previousSummary = taskSummary; - } - } - @WithAccessId(user = "admin") - @Test - void should_sortByTaskIdDesc_When_TaskQueryFilterIsApplied() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByTaskId(SortDirection.DESCENDING) - .list(); + @WithAccessId(user = "admin") + @Test + void should_sortByTaskIdAsc_When_TaskQueryFilterIsApplied() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = taskService.createTaskQuery().orderByTaskId(null).list(); - // test is only valid with at least 2 results - assertThat(results).hasSizeGreaterThan(2); + // test is only valid with at least 2 results + assertThat(results).hasSizeGreaterThan(2); - List idsDesc = - results.stream() - .map(TaskSummary::getId) - .sorted(Comparator.reverseOrder()) - .collect(Collectors.toList()); + List idsAsc = + results.stream().map(TaskSummary::getId).sorted().collect(Collectors.toList()); - for (int i = 0; i < results.size(); i++) { - assertThat(results.get(i).getId()).isEqualTo(idsDesc.get(i)); - } - } - - @WithAccessId(user = "admin") - @Test - void should_sortByTaskIdAsc_When_TaskQueryFilterIsApplied() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByTaskId(null) - .list(); - - // test is only valid with at least 2 results - assertThat(results).hasSizeGreaterThan(2); - - List idsAsc = - results.stream().map(TaskSummary::getId).sorted().collect(Collectors.toList()); - - for (int i = 0; i < results.size(); i++) { - assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i)); - } - } - - @WithAccessId(user = "admin") - @Test - void should_sortByWorkbasketNameAsc_When_TaskQueryFilterIsApplied() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService.createTaskQuery().orderByWorkbasketName(SortDirection.ASCENDING).list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(TaskSummary::getWorkbasketSummary) - .extracting(WorkbasketSummary::getName) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); - } - - @WithAccessId(user = "admin") - @Test - void should_sortByWorkbasketNameDsc_When_TaskQueryFilterIsApplied() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService.createTaskQuery().orderByWorkbasketName(SortDirection.DESCENDING).list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .extracting(TaskSummary::getWorkbasketSummary) - .extracting(WorkbasketSummary::getName) - .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); - } - - @WithAccessId(user = "admin") - @Test - void should_SortByReceivedAsc_When_TaskQueryFilterIsApplied() { - TaskService taskService = taskanaEngine.getTaskService(); - // we filter between EPOCH and null,to avoid null as a received value - List results = - taskService - .createTaskQuery() - .receivedWithin(new TimeInterval(Instant.EPOCH, null)) - .orderByReceived(SortDirection.ASCENDING) - .list(); - - assertThat(results) - .extracting(TaskSummary::getReceived) - .isSortedAccordingTo(Instant::compareTo); - } - - @WithAccessId(user = "admin") - @Test - void testSortByDomainNameAndCreated() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .orderByDomain(SortDirection.ASCENDING) - .orderByName(SortDirection.ASCENDING) - .orderByCreated(null) - .list(); - - assertThat(results) - .hasSizeGreaterThan(2) - .isSortedAccordingTo( - Comparator.comparing(TaskSummary::getDomain, CASE_INSENSITIVE_ORDER) - .thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER) - .thenComparing(TaskSummary::getCreated)); - } - - @WithAccessId(user = "admin") - @Test - void testSortByPorSystemNoteDueAndOwner() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByPrimaryObjectReferenceSystem(SortDirection.DESCENDING) - .orderByNote(null) - .orderByDue(null) - .orderByOwner(SortDirection.ASCENDING) - .list(); - - assertThat(results).hasSize(25); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - if (previousSummary != null) { - assertThat( - taskSummary - .getPrimaryObjRef() - .getSystem() - .compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystem()) - <= 0) - .isTrue(); + for (int i = 0; i < results.size(); i++) { + assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i)); + } } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testSortByPorSystemInstanceParentProcPlannedAndState() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByPrimaryObjectReferenceSystemInstance(SortDirection.DESCENDING) - .orderByParentBusinessProcessId(SortDirection.ASCENDING) - .orderByPlanned(SortDirection.ASCENDING) - .orderByState(SortDirection.ASCENDING) - .list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class WorkbasketName { + @WithAccessId(user = "admin") + @Test + void should_sortByWorkbasketNameAsc_When_TaskQueryFilterIsApplied() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService.createTaskQuery().orderByWorkbasketName(SortDirection.ASCENDING).list(); - assertThat(results).hasSize(25); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - if (previousSummary != null) { - assertThat( - taskSummary - .getPrimaryObjRef() - .getSystemInstance() - .compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystemInstance()) - <= 0) - .isTrue(); + assertThat(results) + .hasSizeGreaterThan(2) + .extracting(TaskSummary::getWorkbasketSummary) + .extracting(WorkbasketSummary::getName) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); + } + + @WithAccessId(user = "admin") + @Test + void should_sortByWorkbasketNameDsc_When_TaskQueryFilterIsApplied() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService.createTaskQuery().orderByWorkbasketName(SortDirection.DESCENDING).list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .extracting(TaskSummary::getWorkbasketSummary) + .extracting(WorkbasketSummary::getName) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testSortByPorCompanyAndClaimed() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) - .orderByPrimaryObjectReferenceCompany(SortDirection.DESCENDING) - .orderByClaimed(SortDirection.ASCENDING) - .list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class Received { + @WithAccessId(user = "admin") + @Test + void should_SortByReceivedAsc_When_TaskQueryFilterIsApplied() { + TaskService taskService = taskanaEngine.getTaskService(); + // we filter between EPOCH and null,to avoid null as a received value + List results = + taskService + .createTaskQuery() + .receivedWithin(new TimeInterval(Instant.EPOCH, null)) + .orderByReceived(SortDirection.ASCENDING) + .list(); - assertThat(results).hasSize(25); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - // System.out.println("porCompany: " + taskSummary.getPrimaryObjRef().getCompany() + ", - // claimed: " - // + taskSummary.getClaimed()); - if (previousSummary != null) { - assertThat( - taskSummary - .getPrimaryObjRef() - .getCompany() - .compareToIgnoreCase(previousSummary.getPrimaryObjRef().getCompany()) - <= 0) - .isTrue(); + assertThat(results) + .extracting(TaskSummary::getReceived) + .isSortedAccordingTo(Instant::compareTo); } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testSortByWbKeyPrioPorValueAndCompleted() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .stateIn(TaskState.READY) - .orderByWorkbasketKey(null) - .workbasketIdIn("WBI:100000000000000000000000000000000015") - .orderByPriority(SortDirection.DESCENDING) - .orderByPrimaryObjectReferenceValue(SortDirection.ASCENDING) - .orderByCompleted(SortDirection.DESCENDING) - .list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class DomainNameAndCreated { + @WithAccessId(user = "admin") + @Test + void testSortByDomainNameAndCreated() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .orderByDomain(SortDirection.ASCENDING) + .orderByName(SortDirection.ASCENDING) + .orderByCreated(null) + .list(); - assertThat(results).hasSize(22); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - if (previousSummary != null) { - assertThat( - taskSummary - .getWorkbasketSummary() - .getKey() - .compareToIgnoreCase(previousSummary.getWorkbasketSummary().getKey()) - >= 0) - .isTrue(); + assertThat(results) + .hasSizeGreaterThan(2) + .isSortedAccordingTo( + Comparator.comparing(TaskSummary::getDomain, CASE_INSENSITIVE_ORDER) + .thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER) + .thenComparing(TaskSummary::getCreated)); } - previousSummary = taskSummary; } - } - @WithAccessId(user = "admin") - @Test - void testSortBpIdClassificationIdDescriptionAndPorType() { - TaskService taskService = taskanaEngine.getTaskService(); - List results = - taskService - .createTaskQuery() - .stateIn(TaskState.READY) - .workbasketIdIn("WBI:100000000000000000000000000000000015") - .orderByBusinessProcessId(SortDirection.ASCENDING) - .orderByClassificationKey(null) - .orderByPrimaryObjectReferenceType(SortDirection.DESCENDING) - .list(); + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class PorSystemNoteDueAndOwner { + @WithAccessId(user = "admin") + @Test + void testSortByPorSystemNoteDueAndOwner() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) + .orderByPrimaryObjectReferenceSystem(SortDirection.DESCENDING) + .orderByNote(null) + .orderByDue(null) + .orderByOwner(SortDirection.ASCENDING) + .list(); - assertThat(results).hasSize(22); - TaskSummary previousSummary = null; - for (TaskSummary taskSummary : results) { - if (previousSummary != null) { - assertThat( - taskSummary - .getBusinessProcessId() - .compareToIgnoreCase(previousSummary.getBusinessProcessId()) - >= 0) - .isTrue(); + assertThat(results).hasSize(25); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + if (previousSummary != null) { + assertThat( + taskSummary + .getPrimaryObjRef() + .getSystem() + .compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystem()) + <= 0) + .isTrue(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class PorSystemInstanceParentBpiPlannedState { + + @WithAccessId(user = "admin") + @Test + void testSortByPorSystemInstanceParentProcPlannedAndState() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) + .orderByPrimaryObjectReferenceSystemInstance(SortDirection.DESCENDING) + .orderByParentBusinessProcessId(SortDirection.ASCENDING) + .orderByPlanned(SortDirection.ASCENDING) + .orderByState(SortDirection.ASCENDING) + .list(); + + assertThat(results).hasSize(25); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + if (previousSummary != null) { + assertThat( + taskSummary + .getPrimaryObjRef() + .getSystemInstance() + .compareToIgnoreCase( + previousSummary.getPrimaryObjRef().getSystemInstance()) + <= 0) + .isTrue(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class PorCompanyClaimed { + @WithAccessId(user = "admin") + @Test + void testSortByPorCompanyAndClaimed() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) + .orderByPrimaryObjectReferenceCompany(SortDirection.DESCENDING) + .orderByClaimed(SortDirection.ASCENDING) + .list(); + + assertThat(results).hasSize(25); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + // System.out.println("porCompany: " + taskSummary.getPrimaryObjRef().getCompany() + ", + // claimed: " + // + taskSummary.getClaimed()); + if (previousSummary != null) { + assertThat( + taskSummary + .getPrimaryObjRef() + .getCompany() + .compareToIgnoreCase(previousSummary.getPrimaryObjRef().getCompany()) + <= 0) + .isTrue(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class WbKeyPriorityPorValueAndCompleted { + @WithAccessId(user = "admin") + @Test + void testSortByWbKeyPrioPorValueAndCompleted() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .stateIn(TaskState.READY) + .orderByWorkbasketKey(null) + .workbasketIdIn("WBI:100000000000000000000000000000000015") + .orderByPriority(SortDirection.DESCENDING) + .orderByPrimaryObjectReferenceValue(SortDirection.ASCENDING) + .orderByCompleted(SortDirection.DESCENDING) + .list(); + + assertThat(results).hasSize(22); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + if (previousSummary != null) { + assertThat( + taskSummary + .getWorkbasketSummary() + .getKey() + .compareToIgnoreCase(previousSummary.getWorkbasketSummary().getKey()) + >= 0) + .isTrue(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class BpiClassificationKeyAndPorType { + @WithAccessId(user = "admin") + @Test + void testSortBpIdClassificationIdDescriptionAndPorType() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .stateIn(TaskState.READY) + .workbasketIdIn("WBI:100000000000000000000000000000000015") + .orderByBusinessProcessId(SortDirection.ASCENDING) + .orderByClassificationKey(null) + .orderByPrimaryObjectReferenceType(SortDirection.DESCENDING) + .list(); + + assertThat(results).hasSize(22); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + if (previousSummary != null) { + assertThat( + taskSummary + .getBusinessProcessId() + .compareToIgnoreCase(previousSummary.getBusinessProcessId()) + >= 0) + .isTrue(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class ModifiedAndDomain { + + @WithAccessId(user = "admin") + @Test + void testSortByModifiedAndDomain() { + TaskService taskService = taskanaEngine.getTaskService(); + List results = + taskService + .createTaskQuery() + .workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B")) + .orderByModified(SortDirection.DESCENDING) + .orderByDomain(null) + .list(); + + assertThat(results).hasSize(25); + TaskSummary previousSummary = null; + for (TaskSummary taskSummary : results) { + if (previousSummary != null) { + assertThat(previousSummary.getModified().isBefore(taskSummary.getModified())).isFalse(); + } + previousSummary = taskSummary; + } + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class Creator { + @WithAccessId(user = "admin") + @Test + void should_ReturnOrderedResult_When_OrderByCreatorDescIsSet() { + List results = + taskanaEngine.getTaskService().createTaskQuery().orderByCreator(DESCENDING).list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .extracting(TaskSummary::getCreator) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class WorkbasketId { + @WithAccessId(user = "admin") + @Test + void should_ReturnOrderedResult_When_OrderByWorkbasketIdDescIsSet() { + List results = + taskanaEngine.getTaskService().createTaskQuery().orderByWorkbasketId(DESCENDING).list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .extracting(TaskSummary::getWorkbasketSummary) + .extracting(WorkbasketSummary::getId) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class ClassificationName { + @Disabled + @WithAccessId(user = "admin") + @Test + void testQueryTaskValuesForClassificationName() { + TaskService taskService = taskanaEngine.getTaskService(); + List columnValueList = + taskService + .createTaskQuery() + .orderByClassificationName(ASCENDING) + .listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null); + assertThat(columnValueList).hasSize(5); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentClassificationName { + @WithAccessId(user = "user-1-1") + @Test + void testSelectByAttachmentClassificationNameLike() { + TaskService taskService = taskanaEngine.getTaskService(); + // find Task with attachment classification names + List tasks = + taskService + .createTaskQuery() + .attachmentClassificationNameLike("Widerruf", "Beratungsprotokoll", "Dynamik%") + .orderByAttachmentClassificationName(ASCENDING) + .list(); + assertThat(tasks).hasSize(10); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class CustomX { + @WithAccessId(user = "admin") + @TestFactory + Stream should_ReturnOrderedResult_When_OrderByCustomXAscIsSet() { + Iterator iterator = Arrays.stream(TaskCustomField.values()).iterator(); + return DynamicTest.stream( + iterator, + s -> String.format("order by %s asc", s), + s -> + should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet( + s, ASCENDING)); + } + + @WithAccessId(user = "admin") + @TestFactory + Stream should_ReturnOrderedResult_When_OrderByCustomXDescIsSet() { + Iterator iterator = Arrays.stream(TaskCustomField.values()).iterator(); + + return DynamicTest.stream( + iterator, + s -> String.format("order by %s desc", s), + s -> + should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet( + s, DESCENDING)); + } + + void should_ReturnOrderedResult_When_OrderByCustomFieldInSortDirectionIsSet( + TaskCustomField customField, SortDirection sortDirection) { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .orderByCustomAttribute(customField, sortDirection) + .list(); + + Comparator comparator = + sortDirection == ASCENDING ? CASE_INSENSITIVE_ORDER : CASE_INSENSITIVE_ORDER.reversed(); + + assertThat(results) + .hasSizeGreaterThan(2) + .extracting(t -> t.getCustomAttribute(customField)) + .filteredOn(Objects::nonNull) + .isSortedAccordingTo(comparator); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentClassificationId { + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentClassificationIdAsc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000009", + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentClassificationId(ASCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getClassificationSummary) + .extracting(ClassificationSummary::getId) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); + } + + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentClassificationIdDesc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000009", + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentClassificationId(DESCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getClassificationSummary) + .extracting(ClassificationSummary::getId) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentClassificationKey { + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentClassificationKeyAsc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000009", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentClassificationKey(ASCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getClassificationSummary) + .extracting(ClassificationSummary::getKey) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); + } + + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentClassificationKeyDesc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000009", + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentClassificationKey(DESCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getClassificationSummary) + .extracting(ClassificationSummary::getKey) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentReference { + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentRefValueDesc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentReference(DESCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getObjectReference) + .extracting(ObjectReference::getValue) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentReceived { + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentReceivedAsc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000008", + "TKI:000000000000000000000000000000000052", + "TKI:000000000000000000000000000000000054") + .orderByAttachmentReceived(ASCENDING) + .list(); + + assertThat(results) + .hasSize(3) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getReceived) + .isSorted(); + } + + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentReceivedDesc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000008", + "TKI:000000000000000000000000000000000052", + "TKI:000000000000000000000000000000000054") + .orderByAttachmentReceived(DESCENDING) + .list(); + + assertThat(results) + .hasSize(3) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .extracting(AttachmentSummary::getReceived) + .isSortedAccordingTo(Comparator.naturalOrder().reversed()); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + class AttachmentChannel { + @WithAccessId(user = "admin") + @Test + void testQueryForOrderByAttachmentChannelAscAndReferenceDesc() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .idIn( + "TKI:000000000000000000000000000000000009", + "TKI:000000000000000000000000000000000010", + "TKI:000000000000000000000000000000000011", + "TKI:000000000000000000000000000000000012") + .orderByAttachmentChannel(ASCENDING) + .orderByAttachmentReference(DESCENDING) + .list(); + + assertThat(results) + .hasSizeGreaterThan(2) + .flatExtracting(TaskSummary::getAttachmentSummaries) + .isSortedAccordingTo( + Comparator.comparing(AttachmentSummary::getChannel, CASE_INSENSITIVE_ORDER) + .thenComparing( + a -> a.getObjectReference().getValue(), CASE_INSENSITIVE_ORDER.reversed())); + } + + @WithAccessId(user = "admin") + @Test + void testQueryForAttachmentChannelLikeAndOrdering() { + List results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .attachmentChannelLike("CH%") + .orderByClassificationKey(DESCENDING) + .list(); + + assertThat(results) + .extracting(TaskSummary::getClassificationSummary) + .extracting(ClassificationSummary::getKey) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); + + results = + taskanaEngine + .getTaskService() + .createTaskQuery() + .attachmentChannelLike("CH%") + .orderByClassificationKey(ASCENDING) + .list(); + + assertThat(results) + .extracting(TaskSummary::getClassificationSummary) + .extracting(ClassificationSummary::getKey) + .isSortedAccordingTo(CASE_INSENSITIVE_ORDER); } - previousSummary = taskSummary; } } }