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 = private final ClassificationService classificationService =
taskanaEngine.getClassificationService(); 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") @WithAccessId(user = "user-1-1")
@Test @Test
void should_BeAbleToCreateNewTask_When_TaskCopy() throws Exception { void should_BeAbleToCreateNewTask_When_TaskCopy() throws Exception {
@ -631,8 +640,7 @@ class CreateTaskAccTest extends AbstractAccTest {
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null)); createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null));
testCreateTask.accept( testCreateTask.accept(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567")); createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
testCreateTask.accept( testCreateTask.accept(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
} }
@WithAccessId(user = "user-1-1") @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; package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest; import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.test.security.JaasExtension; 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 * 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 asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING; 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
}
}

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

@ -1,58 +1,41 @@
package acceptance.task; 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.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq; 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 static pro.taskana.task.api.TaskCustomField.CUSTOM_7;
import acceptance.AbstractAccTest; import acceptance.AbstractAccTest;
import acceptance.TaskTestMapper; import acceptance.TaskTestMapper;
import acceptance.TaskanaEngineProxy; 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.List;
import java.util.Map; import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
import org.apache.ibatis.session.Configuration; import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session.SqlSession;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest; import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory; 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.junit.jupiter.api.extension.ExtendWith;
import org.mockito.MockedStatic; import org.mockito.MockedStatic;
import org.mockito.Mockito; 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.api.exceptions.InvalidArgumentException;
import pro.taskana.common.internal.util.CollectionUtil; import pro.taskana.common.internal.util.CollectionUtil;
import pro.taskana.common.internal.util.Triplet; import pro.taskana.common.internal.util.Triplet;
import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId; import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCustomField; 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.Task;
import pro.taskana.task.api.models.TaskSummary; import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.models.TaskImpl; 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. */ /** Acceptance test for all "query tasks with sorting" scenarios. */
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
@ -246,119 +229,25 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() { void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() {
try (MockedStatic<CollectionUtil> listUtilMock = Mockito.mockStatic(CollectionUtil.class)) { try (MockedStatic<CollectionUtil> listUtilMock =
listUtilMock Mockito.mockStatic(CollectionUtil.class, new CallsRealMethods())) {
.when(() -> CollectionUtil.partitionBasedOnSize(any(), anyInt())) TASK_SERVICE.createTaskQuery().list();
.thenCallRealMethod();
taskService.createTaskQuery().list();
listUtilMock.verify(() -> CollectionUtil.partitionBasedOnSize(any(), eq(32000))); listUtilMock.verify(() -> CollectionUtil.partitionBasedOnSize(any(), eq(32000)));
} }
} }
@WithAccessId(user = "admin") @Nested
@Test @TestInstance(Lifecycle.PER_CLASS)
void should_ReturnCorrectResults_When_QueryingForOwnerLike() { class CustomAttributeTest {
List<TaskSummary> results =
taskService.createTaskQuery().ownerLike("%a%", "%u%").orderByCreated(ASCENDING).list();
assertThat(results).hasSize(39).extracting(TaskSummary::getCreated).isSorted();
}
@WithAccessId(user = "admin")
@Test
void should_FilterOutOwner_When_OwnerNotInIsSet() {
List<TaskSummary> results =
taskService.createTaskQuery().ownerNotIn("user-1-1", "user-1-2").list();
assertThat(results).hasSize(3).extracting(TaskSummary::getOwner).containsOnly("user-b-1");
}
@WithAccessId(user = "admin")
@Test
void should_ReturnCorrectResults_When_QueryingForDescription() {
List<TaskSummary> results = taskService.createTaskQuery().descriptionLike("Lorem%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnCorrectResults_When_QueryingForPriority() {
List<TaskSummary> results = taskService.createTaskQuery().priorityIn(1).list();
assertThat(results).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void testQueryForName() {
List<TaskSummary> results = taskService.createTaskQuery().nameLike("task%").list();
assertThat(results).hasSize(7);
String[] ids = results.stream().map(TaskSummary::getName).toArray(String[]::new);
List<TaskSummary> result2 = taskService.createTaskQuery().nameIn(ids).list();
assertThat(result2).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForClassificationKey() {
List<TaskSummary> results = taskService.createTaskQuery().classificationKeyLike("L10%").list();
assertThat(results).hasSize(78);
String[] ids =
results.stream().map(t -> t.getClassificationSummary().getKey()).toArray(String[]::new);
List<TaskSummary> result2 = taskService.createTaskQuery().classificationKeyIn(ids).list();
assertThat(result2).hasSize(78);
List<TaskSummary> result3 =
taskService.createTaskQuery().classificationKeyNotIn("T2100", "T2000").list();
assertThat(result3).hasSize(83);
List<TaskSummary> result4 =
taskService.createTaskQuery().classificationKeyNotIn("L1050", "L1060", "T2100").list();
assertThat(result4).hasSize(10);
}
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentInSummary() throws Exception {
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));
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.addAttachment(attachment);
taskService.updateTask(task);
List<TaskSummary> results =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertThat(results).hasSize(1);
assertThat(results.get(0).getAttachmentSummaries()).hasSize(3);
assertThat(results.get(0).getAttachmentSummaries().get(0)).isNotNull();
}
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@TestFactory @TestFactory
Stream<DynamicTest> should_ReturnCorrectResults_When_QueryingForCustomXStatements() { Stream<DynamicTest> should_ReturnCorrectResults_When_QueryingForCustomXStatements() {
List<Triplet<TaskCustomField, String[], Integer>> list = List<Triplet<TaskCustomField, String[], Integer>> list =
List.of( List.of(
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3), 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_2, new String[] {"custom%", "a%"}, 2),
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1), Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1),
Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2), Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
@ -383,16 +272,17 @@ class QueryTasksAccTest extends AbstractAccTest {
} }
void testQueryForCustomXLikeAndIn( void testQueryForCustomXLikeAndIn(
TaskCustomField customField, String[] searchArguments, int expectedResult) throws Exception { TaskCustomField customField, String[] searchArguments, int expectedResult)
throws Exception {
List<TaskSummary> results = List<TaskSummary> results =
taskService.createTaskQuery().customAttributeLike(customField, searchArguments).list(); TASK_SERVICE.createTaskQuery().customAttributeLike(customField, searchArguments).list();
assertThat(results).hasSize(expectedResult); assertThat(results).hasSize(expectedResult);
String[] customAttributes = String[] customAttributes =
results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new); results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new);
List<TaskSummary> result2 = List<TaskSummary> result2 =
taskService.createTaskQuery().customAttributeIn(customField, customAttributes).list(); TASK_SERVICE.createTaskQuery().customAttributeIn(customField, customAttributes).list();
assertThat(result2).hasSize(expectedResult); assertThat(result2).hasSize(expectedResult);
} }
@ -429,14 +319,14 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForCustomXNotIn( void testQueryForCustomXNotIn(
TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception { TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception {
long results = long results =
taskService.createTaskQuery().customAttributeNotIn(customField, searchArguments).count(); TASK_SERVICE.createTaskQuery().customAttributeNotIn(customField, searchArguments).count();
assertThat(results).isEqualTo(expectedCount); assertThat(results).isEqualTo(expectedCount);
} }
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testQueryForCustom7WithExceptionInLike() { void testQueryForCustom7WithExceptionInLike() {
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeLike(CUSTOM_7).list()) assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7).list())
.isInstanceOf(InvalidArgumentException.class); .isInstanceOf(InvalidArgumentException.class);
} }
@ -444,10 +334,10 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test @Test
void testQueryForCustom7WithExceptionInIn() throws Exception { void testQueryForCustom7WithExceptionInIn() throws Exception {
List<TaskSummary> results = List<TaskSummary> results =
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list(); TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list();
assertThat(results).isEmpty(); assertThat(results).isEmpty();
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeIn(CUSTOM_7).list()) assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7).list())
.isInstanceOf(InvalidArgumentException.class); .isInstanceOf(InvalidArgumentException.class);
} }
@ -455,27 +345,28 @@ class QueryTasksAccTest extends AbstractAccTest {
@Test @Test
void testQueryForCustom7WithException() throws Exception { void testQueryForCustom7WithException() throws Exception {
List<TaskSummary> results = List<TaskSummary> results =
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list(); TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list();
assertThat(results).hasSize(2); assertThat(results).hasSize(2);
String[] ids = results.stream().map(t -> t.getCustomAttribute(CUSTOM_7)).toArray(String[]::new); String[] ids =
results.stream().map(t -> t.getCustomAttribute(CUSTOM_7)).toArray(String[]::new);
List<TaskSummary> result2 = List<TaskSummary> result2 =
taskService.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list(); TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list();
assertThat(result2).hasSize(2); assertThat(result2).hasSize(2);
} }
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testQueryTaskByCustomAttributes() throws Exception { void testQueryTaskByCustomAttributes() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A"); Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setPrimaryObjRef( newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")); createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
newTask.setClassificationKey("T2100"); newTask.setClassificationKey("T2100");
Map<String, String> customAttributesForCreate = Map<String, String> customAttributesForCreate =
createSimpleCustomPropertyMap(20000); // about 1 Meg createSimpleCustomPropertyMap(20000); // about 1 Meg
newTask.setCustomAttributeMap(customAttributesForCreate); newTask.setCustomAttributeMap(customAttributesForCreate);
Task createdTask = taskService.createTask(newTask); Task createdTask = TASK_SERVICE.createTask(newTask);
assertThat(createdTask).isNotNull(); assertThat(createdTask).isNotNull();
// query the task by custom attributes // query the task by custom attributes
@ -505,540 +396,5 @@ class QueryTasksAccTest extends AbstractAccTest {
engineProxy.returnConnection(); engineProxy.returnConnection();
} }
} }
@WithAccessId(user = "admin")
@Test
void should_QueryAndCountMatch_When_CalledWithSameQuery() {
TaskQuery taskQuery = taskService.createTaskQuery();
List<TaskSummary> 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<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 = "admin")
@Test
void should_ReturnCorrectResults_When_QueryingForReceivedWithUpperBoundTimeInterval() {
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> results =
taskService.createTaskQuery().creatorIn("creator_user_id2", "creator_user_id3").list();
assertThat(results).hasSize(4);
}
@WithAccessId(user = "admin")
@Test
void testQueryForCreatorLike() {
List<TaskSummary> results = taskService.createTaskQuery().creatorLike("ersTeLlEr%").list();
assertThat(results).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void testQueryForNoteLike() {
List<TaskSummary> results = taskService.createTaskQuery().noteLike("Some%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForClassificationCategoryIn() {
List<TaskSummary> results =
taskService.createTaskQuery().classificationCategoryIn("MANUAL", "AUTOMATIC").list();
assertThat(results).hasSize(4);
}
@WithAccessId(user = "admin")
@Test
void testQueryForClassificationCategoryLike() {
List<TaskSummary> results =
taskService.createTaskQuery().classificationCategoryLike("AUTO%").list();
assertThat(results).hasSize(1);
}
@WithAccessId(user = "admin")
@Test
void testQueryForPrimaryObjectReferenceCompanyLike() {
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceCompanyLike("My%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForPrimaryObjectReferenceSystemLike() {
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceSystemLike("My%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForPrimaryObjectReferenceSystemInstanceLike() {
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceSystemInstanceLike("My%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForPrimaryObjectReferenceTypeLike() {
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceTypeLike("My%").list();
assertThat(results).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void testQueryForReadEquals() {
List<TaskSummary> results = taskService.createTaskQuery().readEquals(true).list();
assertThat(results).hasSize(39);
}
@WithAccessId(user = "admin")
@Test
void testQueryForTransferredEquals() {
List<TaskSummary> results = taskService.createTaskQuery().transferredEquals(true).list();
assertThat(results).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void testQueryForBusinessProcessIdIn() {
List<TaskSummary> results =
taskService.createTaskQuery().businessProcessIdIn("PI_0000000000003", "BPI21").list();
assertThat(results).hasSize(9);
}
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentClassificationKeyIn() {
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> results = taskService.createTaskQuery().attachmentChannelLike("%6").list();
assertThat(results).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentReferenceIn() {
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<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 =
taskService.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);
}
@WithAccessId(user = "admin")
@Test
void testQueryForOrderWithDirectionNull() {
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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.<Instant>naturalOrder().reversed());
}
@WithAccessId(user = "admin")
@Test
void testQueryForOrderByAttachmentChannelAscAndReferenceDesc() {
List<TaskSummary> 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<TaskSummary> 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<TaskSummary> 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<TaskSummary> result2 = taskService.createTaskQuery().idIn(ids).list();
assertThat(result2).hasSize(10);
} }
} }

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);
}
}

8
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 acceptance.AbstractAccTest;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate; import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
@ -18,6 +19,9 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksByRoleAccTest extends AbstractAccTest { class QueryTasksByRoleAccTest extends AbstractAccTest {
@Nested
class RoleTest {
@Test @Test
void should_ReturnNoResult_When_UserIsNotAuthenticated() { void should_ReturnNoResult_When_UserIsNotAuthenticated() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
@ -57,9 +61,11 @@ class QueryTasksByRoleAccTest extends AbstractAccTest {
break; break;
default: default:
throw new SystemException( throw new SystemException(
String.format("Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid())); String.format(
"Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid()));
} }
assertThat(results).hasSize(expectedSize); assertThat(results).hasSize(expectedSize);
} }
} }
}

78
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 acceptance.AbstractAccTest;
import java.time.Instant; import java.time.Instant;
import java.util.List; import java.util.List;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; 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 org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.api.BaseQuery.SortDirection;
@ -18,13 +21,15 @@ import pro.taskana.task.api.models.TaskSummary;
/** Acceptance test for all "query tasks with sorting" scenarios. */ /** Acceptance test for all "query tasks with sorting" scenarios. */
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest { class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING; private static SortDirection asc = SortDirection.ASCENDING;
QueryTasksByTimeIntervalsAccTest() { QueryTasksByTimeIntervalsAccTest() {
super(); super();
} }
@Nested
class TimeIntervalTest {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testCreatedWithin2Intervals() { void testCreatedWithin2Intervals() {
@ -222,4 +227,75 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
previousSummary = taskSummary; 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);
}
}
}
} }

37
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 acceptance.AbstractAccTest;
import java.util.List; import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
@ -18,6 +19,9 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksByWildcardSearchAccTest extends AbstractAccTest { class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
@Nested
class WildcardSearchTest {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_ReturnAllTasksByWildcardSearch_For_ProvidedSearchValue() { void should_ReturnAllTasksByWildcardSearch_For_ProvidedSearchValue() {
@ -26,7 +30,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
}; };
List<TaskSummary> foundTasks = List<TaskSummary> foundTasks =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchFieldsIn(wildcards) .wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%") .wildcardSearchValueLike("%99%")
@ -44,7 +48,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
}; };
long foundTasks = long foundTasks =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchFieldsIn(wildcards) .wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%") .wildcardSearchValueLike("%99%")
@ -54,20 +58,40 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
assertThat(foundTasks).isEqualTo(4); assertThat(foundTasks).isEqualTo(4);
} }
@WithAccessId(user = "admin")
@Test
void should_ReturnAllTasks_For_ProvidedSearchValueAndAdditionalParameters() {
WildcardSearchField[] wildcards = {
WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME
};
List<TaskSummary> foundTasks =
TASK_SERVICE
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%")
.ownerIn("user-1-1")
.businessProcessIdLike("%PI2%")
.orderByName(SortDirection.ASCENDING)
.list();
assertThat(foundTasks).hasSize(1);
}
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() { void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() {
WildcardSearchField[] wildcards = {WildcardSearchField.NAME}; WildcardSearchField[] wildcards = {WildcardSearchField.NAME};
List<TaskSummary> foundTasksCaseSensitive = List<TaskSummary> foundTasksCaseSensitive =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchFieldsIn(wildcards) .wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%Wid%") .wildcardSearchValueLike("%Wid%")
.list(); .list();
List<TaskSummary> foundTasksCaseInsensitive = List<TaskSummary> foundTasksCaseInsensitive =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchFieldsIn(wildcards) .wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%wid%") .wildcardSearchValueLike("%wid%")
@ -83,7 +107,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
ThrowingCallable queryAttempt = ThrowingCallable queryAttempt =
() -> () ->
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchValueLike("%99%") .wildcardSearchValueLike("%99%")
.orderByName(SortDirection.ASCENDING) .orderByName(SortDirection.ASCENDING)
@ -93,7 +117,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
queryAttempt = queryAttempt =
() -> () ->
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.wildcardSearchFieldsIn( .wildcardSearchFieldsIn(
WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION) WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION)
@ -103,3 +127,4 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class);
} }
} }
}

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

@ -1,50 +1,28 @@
package acceptance.task; package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest; import acceptance.AbstractAccTest;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable; import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test; 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 org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.KeyDomain; import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId; import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService; import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.workbasket.api.exceptions.NotAuthorizedToQueryWorkbasketException; import pro.taskana.workbasket.api.exceptions.NotAuthorizedToQueryWorkbasketException;
/** Acceptance test for all "query tasks by workbasket" scenarios. */ /** Acceptance test for all "query tasks by workbasket" scenarios. */
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksByWorkbasketAccTest extends AbstractAccTest { class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
QueryTasksByWorkbasketAccTest() { @Nested
super(); @TestInstance(Lifecycle.PER_CLASS)
} class WorkbasketTest {
@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"));
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") @WithAccessId(user = "user-1-1")
@Test @Test
void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() { void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() {
@ -73,3 +51,4 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class); assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class);
} }
} }
}

68
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.Arrays;
import java.util.List; import java.util.List;
import org.assertj.core.api.SoftAssertions; 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.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.api.BaseQuery.SortDirection;
@ -22,11 +26,46 @@ import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId; import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskQueryColumnName; 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. */ /** Acceptance test for listing the column values within a workbasket. */
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksListValuesAccTest extends AbstractAccTest { class QueryTasksListValuesAccTest extends AbstractAccTest {
private static final TaskServiceImpl TASK_SERVICE =
(TaskServiceImpl) taskanaEngine.getTaskService();
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class ListValuesTest {
@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 testQueryTaskValuesForClassificationName() {
TaskService taskService = taskanaEngine.getTaskService();
List<String> columnValueList =
taskService
.createTaskQuery()
.ownerLike("%user%")
.orderByClassificationName(ASCENDING)
.listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null);
assertThat(columnValueList).hasSize(5);
}
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() { void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() {
@ -36,7 +75,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
columnName -> columnName ->
softly softly
.assertThatCode( .assertThatCode(
() -> taskService.createTaskQuery().listValues(columnName, ASCENDING)) () -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING))
.describedAs("Column is not working " + columnName) .describedAs("Column is not working " + columnName)
.doesNotThrowAnyException()); .doesNotThrowAnyException());
softly.assertAll(); softly.assertAll();
@ -46,7 +85,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@Test @Test
void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() { void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() {
List<String> columnValueList = List<String> columnValueList =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.ownerLike("%user%") .ownerLike("%user%")
.orderByOwner(DESCENDING) .orderByOwner(DESCENDING)
@ -57,7 +96,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_ReturnStateValues_When_ListValuesForStateIsInvoked() { void should_ReturnStateValues_When_ListValuesForStateIsInvoked() {
List<String> columnValueList = taskService.createTaskQuery().listValues(STATE, null); List<String> columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).hasSize(5); assertThat(columnValueList).hasSize(5);
} }
@ -65,40 +104,50 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
@Test @Test
void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() { void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() {
List<String> columnValueList = List<String> columnValueList =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.attachmentReferenceValueIn("val4") .attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null); .listValues(A_CHANNEL, null);
assertThat(columnValueList).hasSize(2); assertThat(columnValueList).hasSize(2);
columnValueList = columnValueList =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.attachmentReferenceValueLike("%") .attachmentReferenceValueLike("%")
.listValues(A_REF_VALUE, null); .listValues(A_REF_VALUE, null);
assertThat(columnValueList).hasSize(6); assertThat(columnValueList).hasSize(6);
columnValueList = columnValueList =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.orderByAttachmentClassificationId(DESCENDING) .orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null); .listValues(A_CLASSIFICATION_ID, null);
assertThat(columnValueList).hasSize(11); assertThat(columnValueList).hasSize(11);
columnValueList = columnValueList =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.orderByClassificationKey(DESCENDING) .orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null); .listValues(CLASSIFICATION_KEY, null);
assertThat(columnValueList).hasSize(7); 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") @WithAccessId(user = "teamlead-1")
@Test @Test
void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() { void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> porTypes = List<String> porTypes =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.workbasketKeyDomainIn(keyDomain) .workbasketKeyDomainIn(keyDomain)
.primaryObjectReferenceCompanyIn("00", "11") .primaryObjectReferenceCompanyIn("00", "11")
@ -111,7 +160,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() { void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A"); KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> attachmentClassificationNames = List<String> attachmentClassificationNames =
taskService TASK_SERVICE
.createTaskQuery() .createTaskQuery()
.workbasketKeyDomainIn(keyDomain) .workbasketKeyDomainIn(keyDomain)
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING); .listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING);
@ -121,3 +170,4 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung"); null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung");
} }
} }
}

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

@ -1,15 +1,21 @@
package acceptance.task; package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
import acceptance.AbstractAccTest; import acceptance.AbstractAccTest;
import java.util.List; 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.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.KeyDomain; import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId; import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskService; import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.TaskSummary; import pro.taskana.task.api.models.TaskSummary;
@ -17,19 +23,31 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksWithPaginationAccTest extends AbstractAccTest { class QueryTasksWithPaginationAccTest extends AbstractAccTest {
QueryTasksWithPaginationAccTest() { @Nested
super(); class PaginationTest {
@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);
} }
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class OffsetAndLimit {
@WithAccessId(user = "teamlead-1") @WithAccessId(user = "teamlead-1")
@Test @Test
void testGetFirstPageOfTaskQueryWithOffset() { void testGetFirstPageOfTaskQueryWithOffset() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = List<TaskSummary> results = taskService.createTaskQuery().list(0, 10);
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(0, 10);
assertThat(results).hasSize(10); assertThat(results).hasSize(10);
} }
@ -37,11 +55,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
@Test @Test
void testSecondPageOfTaskQueryWithOffset() { void testSecondPageOfTaskQueryWithOffset() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = List<TaskSummary> results = taskService.createTaskQuery().list(10, 10);
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(10, 10);
assertThat(results).hasSize(10); assertThat(results).hasSize(10);
} }
@ -51,11 +65,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
// both will be 0, working // both will be 0, working
List<TaskSummary> results = List<TaskSummary> results = taskService.createTaskQuery().list(-1, -3);
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(-1, -3);
assertThat(results).isEmpty(); assertThat(results).isEmpty();
// limit will be 0 // limit will be 0
@ -74,7 +84,11 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.list(-1, 3); .list(-1, 3);
assertThat(results).hasSize(3); assertThat(results).hasSize(3);
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class ListPage {
@WithAccessId(user = "teamlead-1") @WithAccessId(user = "teamlead-1")
@Test @Test
void testPaginationWithPages() { void testPaginationWithPages() {
@ -156,24 +170,19 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.listPage(pageNumber, pageSize); .listPage(pageNumber, pageSize);
assertThat(results).hasSize(10); assertThat(results).hasSize(10);
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class Count {
@Disabled()
@WithAccessId(user = "teamlead-1") @WithAccessId(user = "teamlead-1")
@Test @Test
void testCountOfTaskQuery() { void testCountOfTaskQuery() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
long count = long count = taskService.createTaskQuery().count();
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.count();
assertThat(count).isEqualTo(22L); assertThat(count).isEqualTo(22L);
} }
}
@WithAccessId(user = "teamlead-1")
@Test
void testCountOfTaskQueryWithAttachmentChannelFilter() {
TaskService taskService = taskanaEngine.getTaskService();
long count = taskService.createTaskQuery().attachmentChannelIn("ch6").count();
assertThat(count).isEqualTo(1L);
} }
} }

471
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 java.lang.String.CASE_INSENSITIVE_ORDER;
import static org.assertj.core.api.Assertions.assertThat; 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 acceptance.AbstractAccTest;
import java.time.Instant; import java.time.Instant;
import java.util.Arrays;
import java.util.Comparator; import java.util.Comparator;
import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors; 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.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.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.BaseQuery.SortDirection; import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.KeyDomain; import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.api.TimeInterval; import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.test.security.JaasExtension; import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId; 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.TaskService;
import pro.taskana.task.api.TaskState; 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.task.api.models.TaskSummary;
import pro.taskana.workbasket.api.models.WorkbasketSummary; import pro.taskana.workbasket.api.models.WorkbasketSummary;
@ -25,42 +42,19 @@ import pro.taskana.workbasket.api.models.WorkbasketSummary;
@ExtendWith(JaasExtension.class) @ExtendWith(JaasExtension.class)
class QueryTasksWithSortingAccTest extends AbstractAccTest { class QueryTasksWithSortingAccTest extends AbstractAccTest {
QueryTasksWithSortingAccTest() { @Nested
super(); class SortingTest {
}
@WithAccessId(user = "admin") @Nested
@Test @TestInstance(Lifecycle.PER_CLASS)
void testSortByModifiedAndDomain() { class TaskId {
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;
}
}
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_sortByTaskIdDesc_When_TaskQueryFilterIsApplied() { void should_sortByTaskIdDesc_When_TaskQueryFilterIsApplied() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = List<TaskSummary> results =
taskService taskService.createTaskQuery().orderByTaskId(SortDirection.DESCENDING).list();
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B"))
.orderByTaskId(SortDirection.DESCENDING)
.list();
// test is only valid with at least 2 results // test is only valid with at least 2 results
assertThat(results).hasSizeGreaterThan(2); assertThat(results).hasSizeGreaterThan(2);
@ -80,12 +74,7 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
@Test @Test
void should_sortByTaskIdAsc_When_TaskQueryFilterIsApplied() { void should_sortByTaskIdAsc_When_TaskQueryFilterIsApplied() {
TaskService taskService = taskanaEngine.getTaskService(); TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = List<TaskSummary> results = taskService.createTaskQuery().orderByTaskId(null).list();
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("USER-B-2", "DOMAIN_B"))
.orderByTaskId(null)
.list();
// test is only valid with at least 2 results // test is only valid with at least 2 results
assertThat(results).hasSizeGreaterThan(2); assertThat(results).hasSizeGreaterThan(2);
@ -97,7 +86,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i)); assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i));
} }
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class WorkbasketName {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_sortByWorkbasketNameAsc_When_TaskQueryFilterIsApplied() { void should_sortByWorkbasketNameAsc_When_TaskQueryFilterIsApplied() {
@ -125,7 +118,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.extracting(WorkbasketSummary::getName) .extracting(WorkbasketSummary::getName)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed()); .isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class Received {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void should_SortByReceivedAsc_When_TaskQueryFilterIsApplied() { void should_SortByReceivedAsc_When_TaskQueryFilterIsApplied() {
@ -142,7 +139,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.extracting(TaskSummary::getReceived) .extracting(TaskSummary::getReceived)
.isSortedAccordingTo(Instant::compareTo); .isSortedAccordingTo(Instant::compareTo);
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class DomainNameAndCreated {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testSortByDomainNameAndCreated() { void testSortByDomainNameAndCreated() {
@ -162,7 +163,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER) .thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER)
.thenComparing(TaskSummary::getCreated)); .thenComparing(TaskSummary::getCreated));
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class PorSystemNoteDueAndOwner {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testSortByPorSystemNoteDueAndOwner() { void testSortByPorSystemNoteDueAndOwner() {
@ -192,6 +197,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
previousSummary = taskSummary; previousSummary = taskSummary;
} }
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class PorSystemInstanceParentBpiPlannedState {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
@ -215,14 +225,19 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
taskSummary taskSummary
.getPrimaryObjRef() .getPrimaryObjRef()
.getSystemInstance() .getSystemInstance()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystemInstance()) .compareToIgnoreCase(
previousSummary.getPrimaryObjRef().getSystemInstance())
<= 0) <= 0)
.isTrue(); .isTrue();
} }
previousSummary = taskSummary; previousSummary = taskSummary;
} }
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class PorCompanyClaimed {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testSortByPorCompanyAndClaimed() { void testSortByPorCompanyAndClaimed() {
@ -253,7 +268,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
previousSummary = taskSummary; previousSummary = taskSummary;
} }
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class WbKeyPriorityPorValueAndCompleted {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testSortByWbKeyPrioPorValueAndCompleted() { void testSortByWbKeyPrioPorValueAndCompleted() {
@ -284,7 +303,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
previousSummary = taskSummary; previousSummary = taskSummary;
} }
} }
}
@Nested
@TestInstance(Lifecycle.PER_CLASS)
class BpiClassificationKeyAndPorType {
@WithAccessId(user = "admin") @WithAccessId(user = "admin")
@Test @Test
void testSortBpIdClassificationIdDescriptionAndPorType() { void testSortBpIdClassificationIdDescriptionAndPorType() {
@ -314,3 +337,379 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
} }
} }
} }
@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);
}
}
}
}