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

TSK-1743: Deleted some Tests and started grouping tests together

This commit is contained in:
Lia Lissmann 2021-10-05 14:37:59 +02:00 committed by LiaLissmann
parent ecdf333c8e
commit 8047e97c15
12 changed files with 1489 additions and 1956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java
View File

@ -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")

154
lib/taskana-core/src/test/java/acceptance/task/QueryTaskByClassificationNameAccTest.java
View File

@ -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<String> 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<String> 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<TaskSummary> tasks =
taskService.createTaskQuery().classificationNameIn("Dynamik-Ablehnung").list();
assertThat(tasks).hasSize(1);
List<AttachmentSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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.
}
}

83
lib/taskana-core/src/test/java/acceptance/task/QueryTaskWithAttachmentAccTest.java
View File

@ -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<Object> REFERENCE_COMPARATOR = (o1, o2) -> o1 == o2 ? 0 : -1;
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTaskSummaryIncludingAttachments_When_QueryingTaskWithAttachments() {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> tasks = taskService.createTaskQuery().classificationKeyIn("L110102").list();
assertThat(tasks).hasSize(1);
List<AttachmentSummary> 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<TaskSummary> tasks = taskService.createTaskQuery().list();
assertThat(tasks).hasSize(30);
List<AttachmentSummary> 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<TaskSummary> tasks =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertThat(tasks).hasSize(1);
List<AttachmentSummary> queryAttachmentSummaries = tasks.get(0).getAttachmentSummaries();
Task originalTask = taskService.getTask("TKI:000000000000000000000000000000000000");
List<AttachmentSummary> 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
}
}

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

File diff suppressed because it is too large Load Diff

138
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java
View File

@ -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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> results =
taskService
.createTaskQuery()
.primaryObjectReferenceTypeIn("SDNR")
.primaryObjectReferenceValueIn("11223344")
.list();
assertThat(results).hasSize(10);
}
@WithAccessId(user = "admin")
@Test
void should_ApplyObjectReferenceFilter_When_ValueLikeIsSet() {
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceValueLike("%567%").list();
assertThat(results).hasSize(10);
}
}

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

@ -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<TaskSummary> results = taskService.createTaskQuery().list();
@Test
void should_ReturnNoResult_When_UserIsNotAuthenticated() {
TaskService taskService = taskanaEngine.getTaskService();
assertThat(results).isEmpty();
}
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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);
}
}
}

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

@ -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<TaskSummary> 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<TaskSummary> 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<TaskSummary> results =
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
List<TaskSummary> 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<TaskSummary> results =
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
List<TaskSummary> 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<TaskSummary> results =
taskService
.createTaskQuery()
.claimedWithin(interval1, interval2)
.orderByCreated(asc)
.list();
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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;
}
}
}

163
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java
View File

@ -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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> foundTasksCaseInsensitive =
taskService
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%wid%")
.list();
List<TaskSummary> 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<TaskSummary> foundTasksCaseSensitive =
TASK_SERVICE
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%Wid%")
.list();
assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class);
List<TaskSummary> 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);
}
}
}

83
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWorkbasketAccTest.java
View File

@ -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<KeyDomain> 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<TaskSummary> 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<TaskSummary> 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);
}
}
}

218
lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java
View File

@ -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<String> 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<String> columnValueList = taskService.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).hasSize(5);
}
@WithAccessId(user = "admin")
@Test
void testQueryTaskValuesForAttachmentClassificationName() {
TaskService taskService = taskanaEngine.getTaskService();
List<String> 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<String> columnValueList =
taskService
.createTaskQuery()
.attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null);
assertThat(columnValueList).hasSize(2);
@WithAccessId(user = "admin")
@Test
void testQueryTaskValuesForClassificationName() {
TaskService taskService = taskanaEngine.getTaskService();
List<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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");
}
}
}

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

@ -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<TaskSummary> 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<TaskSummary> tasks = taskQuery.orderByDue(DESCENDING).list();
assertThat(tasks).hasSize(88);
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> results = taskService.createTaskQuery().list(10, 10);
assertThat(results).hasSize(10);
}
// both will be 0, working
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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);
}
}
}
}

923
lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java
View File

@ -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<TaskSummary> 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<TaskSummary> results =
taskService.createTaskQuery().orderByTaskId(SortDirection.DESCENDING).list();
// test is only valid with at least 2 results
assertThat(results).hasSizeGreaterThan(2);
List<String> 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<TaskSummary> 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<TaskSummary> 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<String> idsDesc =
results.stream()
.map(TaskSummary::getId)
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
List<String> 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<TaskSummary> 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<String> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<String> 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<TaskSummary> 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<DynamicTest> should_ReturnOrderedResult_When_OrderByCustomXAscIsSet() {
Iterator<TaskCustomField> 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<DynamicTest> should_ReturnOrderedResult_When_OrderByCustomXDescIsSet() {
Iterator<TaskCustomField> 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<TaskSummary> results =
taskanaEngine
.getTaskService()
.createTaskQuery()
.orderByCustomAttribute(customField, sortDirection)
.list();
Comparator<String> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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.<Instant>naturalOrder().reversed());
}
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class AttachmentChannel {
@WithAccessId(user = "admin")
@Test
void testQueryForOrderByAttachmentChannelAscAndReferenceDesc() {
List<TaskSummary> 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<TaskSummary> 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;
}
}
}