TSK-1743: Deleted some Tests and started grouping tests together
This commit is contained in:
Lia Lissmann
LiaLissmann
parent
ecdf333c8e
commit
8047e97c15
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
@ -1,58 +1,41 @@
|
|||
package acceptance.task;
|
||||
|
||||
import static java.lang.String.CASE_INSENSITIVE_ORDER;
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.anyInt;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;
|
||||
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
|
||||
import static pro.taskana.task.api.TaskCustomField.CUSTOM_7;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import acceptance.TaskTestMapper;
|
||||
import acceptance.TaskanaEngineProxy;
|
||||
import java.time.Instant;
|
||||
import java.util.Arrays;
|
||||
import java.util.Comparator;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
import org.apache.ibatis.session.Configuration;
|
||||
import org.apache.ibatis.session.SqlSession;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.DynamicTest;
|
||||
import org.junit.jupiter.api.Nested;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestFactory;
|
||||
import org.junit.jupiter.api.TestInstance;
|
||||
import org.junit.jupiter.api.TestInstance.Lifecycle;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.mockito.MockedStatic;
|
||||
import org.mockito.Mockito;
|
||||
import org.mockito.internal.stubbing.answers.CallsRealMethods;
|
||||
|
||||
import pro.taskana.classification.api.models.ClassificationSummary;
|
||||
import pro.taskana.common.api.BaseQuery.SortDirection;
|
||||
import pro.taskana.common.api.TimeInterval;
|
||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.common.internal.util.CollectionUtil;
|
||||
import pro.taskana.common.internal.util.Triplet;
|
||||
import pro.taskana.common.test.security.JaasExtension;
|
||||
import pro.taskana.common.test.security.WithAccessId;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskQuery;
|
||||
import pro.taskana.task.api.TaskQueryColumnName;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.models.Attachment;
|
||||
import pro.taskana.task.api.models.AttachmentSummary;
|
||||
import pro.taskana.task.api.models.ObjectReference;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.api.models.TaskSummary;
|
||||
import pro.taskana.task.internal.models.TaskImpl;
|
||||
import pro.taskana.user.api.exceptions.UserNotFoundException;
|
||||
import pro.taskana.workbasket.api.models.WorkbasketSummary;
|
||||
|
||||
/** Acceptance test for all "query tasks with sorting" scenarios. */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
|
|
@ -246,119 +229,25 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() {
|
||||
try (MockedStatic<CollectionUtil> listUtilMock = Mockito.mockStatic(CollectionUtil.class)) {
|
||||
listUtilMock
|
||||
.when(() -> CollectionUtil.partitionBasedOnSize(any(), anyInt()))
|
||||
.thenCallRealMethod();
|
||||
|
||||
taskService.createTaskQuery().list();
|
||||
try (MockedStatic<CollectionUtil> listUtilMock =
|
||||
Mockito.mockStatic(CollectionUtil.class, new CallsRealMethods())) {
|
||||
TASK_SERVICE.createTaskQuery().list();
|
||||
|
||||
listUtilMock.verify(() -> CollectionUtil.partitionBasedOnSize(any(), eq(32000)));
|
||||
}
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_ReturnCorrectResults_When_QueryingForOwnerLike() {
|
||||
List<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();
|
||||
}
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class CustomAttributeTest {
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@TestFactory
|
||||
Stream<DynamicTest> should_ReturnCorrectResults_When_QueryingForCustomXStatements() {
|
||||
List<Triplet<TaskCustomField, String[], Integer>> list =
|
||||
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_3, new String[] {"ffg"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
|
||||
|
|
@ -383,16 +272,17 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
}
|
||||
|
||||
void testQueryForCustomXLikeAndIn(
|
||||
TaskCustomField customField, String[] searchArguments, int expectedResult) throws Exception {
|
||||
TaskCustomField customField, String[] searchArguments, int expectedResult)
|
||||
throws Exception {
|
||||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().customAttributeLike(customField, searchArguments).list();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeLike(customField, searchArguments).list();
|
||||
assertThat(results).hasSize(expectedResult);
|
||||
|
||||
String[] customAttributes =
|
||||
results.stream().map(t -> t.getCustomAttribute(customField)).toArray(String[]::new);
|
||||
|
||||
List<TaskSummary> result2 =
|
||||
taskService.createTaskQuery().customAttributeIn(customField, customAttributes).list();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeIn(customField, customAttributes).list();
|
||||
assertThat(result2).hasSize(expectedResult);
|
||||
}
|
||||
|
||||
|
|
@ -429,14 +319,14 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
void testQueryForCustomXNotIn(
|
||||
TaskCustomField customField, String[] searchArguments, int expectedCount) throws Exception {
|
||||
long results =
|
||||
taskService.createTaskQuery().customAttributeNotIn(customField, searchArguments).count();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeNotIn(customField, searchArguments).count();
|
||||
assertThat(results).isEqualTo(expectedCount);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testQueryForCustom7WithExceptionInLike() {
|
||||
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeLike(CUSTOM_7).list())
|
||||
assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7).list())
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
|
|
@ -444,10 +334,10 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void testQueryForCustom7WithExceptionInIn() throws Exception {
|
||||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "fsdhfshk%").list();
|
||||
assertThat(results).isEmpty();
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeIn(CUSTOM_7).list())
|
||||
assertThatThrownBy(() -> TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7).list())
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
|
|
@ -455,27 +345,28 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void testQueryForCustom7WithException() throws Exception {
|
||||
List<TaskSummary> results =
|
||||
taskService.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeLike(CUSTOM_7, "%").list();
|
||||
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 =
|
||||
taskService.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list();
|
||||
TASK_SERVICE.createTaskQuery().customAttributeIn(CUSTOM_7, ids).list();
|
||||
assertThat(result2).hasSize(2);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testQueryTaskByCustomAttributes() throws Exception {
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
newTask.setClassificationKey("T2100");
|
||||
Map<String, String> customAttributesForCreate =
|
||||
createSimpleCustomPropertyMap(20000); // about 1 Meg
|
||||
newTask.setCustomAttributeMap(customAttributesForCreate);
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
Task createdTask = TASK_SERVICE.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
// query the task by custom attributes
|
||||
|
|
@ -505,540 +396,5 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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,6 +19,9 @@ import pro.taskana.task.api.models.TaskSummary;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class QueryTasksByRoleAccTest extends AbstractAccTest {
|
||||
|
||||
@Nested
|
||||
class RoleTest {
|
||||
|
||||
@Test
|
||||
void should_ReturnNoResult_When_UserIsNotAuthenticated() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
|
@ -57,9 +61,11 @@ class QueryTasksByRoleAccTest extends AbstractAccTest {
|
|||
break;
|
||||
default:
|
||||
throw new SystemException(
|
||||
String.format("Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid()));
|
||||
String.format(
|
||||
"Invalid User: '%s'", taskanaEngine.getCurrentUserContext().getUserid()));
|
||||
}
|
||||
|
||||
assertThat(results).hasSize(expectedSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,13 +21,15 @@ 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();
|
||||
}
|
||||
|
||||
@Nested
|
||||
class TimeIntervalTest {
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testCreatedWithin2Intervals() {
|
||||
|
|
@ -222,4 +227,75 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
|
|||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,6 +19,9 @@ import pro.taskana.task.api.models.TaskSummary;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
||||
|
||||
@Nested
|
||||
class WildcardSearchTest {
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_ReturnAllTasksByWildcardSearch_For_ProvidedSearchValue() {
|
||||
|
|
@ -26,7 +30,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
};
|
||||
|
||||
List<TaskSummary> foundTasks =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchFieldsIn(wildcards)
|
||||
.wildcardSearchValueLike("%99%")
|
||||
|
|
@ -44,7 +48,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
};
|
||||
|
||||
long foundTasks =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchFieldsIn(wildcards)
|
||||
.wildcardSearchValueLike("%99%")
|
||||
|
|
@ -54,20 +58,40 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
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")
|
||||
@Test
|
||||
void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() {
|
||||
WildcardSearchField[] wildcards = {WildcardSearchField.NAME};
|
||||
|
||||
List<TaskSummary> foundTasksCaseSensitive =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchFieldsIn(wildcards)
|
||||
.wildcardSearchValueLike("%Wid%")
|
||||
.list();
|
||||
|
||||
List<TaskSummary> foundTasksCaseInsensitive =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchFieldsIn(wildcards)
|
||||
.wildcardSearchValueLike("%wid%")
|
||||
|
|
@ -83,7 +107,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
|
||||
ThrowingCallable queryAttempt =
|
||||
() ->
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchValueLike("%99%")
|
||||
.orderByName(SortDirection.ASCENDING)
|
||||
|
|
@ -93,7 +117,7 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
|
||||
queryAttempt =
|
||||
() ->
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.wildcardSearchFieldsIn(
|
||||
WildcardSearchField.CUSTOM_1, WildcardSearchField.DESCRIPTION)
|
||||
|
|
@ -103,3 +127,4 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
|
|||
assertThatThrownBy(queryAttempt).isInstanceOf(IllegalArgumentException.class);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,50 +1,28 @@
|
|||
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();
|
||||
}
|
||||
|
||||
@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);
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WorkbasketTest {
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() {
|
||||
|
|
@ -73,3 +51,4 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
|
|||
assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,11 +26,46 @@ 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 {
|
||||
|
||||
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")
|
||||
@Test
|
||||
void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() {
|
||||
|
|
@ -36,7 +75,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
columnName ->
|
||||
softly
|
||||
.assertThatCode(
|
||||
() -> taskService.createTaskQuery().listValues(columnName, ASCENDING))
|
||||
() -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING))
|
||||
.describedAs("Column is not working " + columnName)
|
||||
.doesNotThrowAnyException());
|
||||
softly.assertAll();
|
||||
|
|
@ -46,7 +85,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() {
|
||||
List<String> columnValueList =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.ownerLike("%user%")
|
||||
.orderByOwner(DESCENDING)
|
||||
|
|
@ -57,7 +96,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
|
||||
|
|
@ -65,40 +104,50 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() {
|
||||
List<String> columnValueList =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.attachmentReferenceValueIn("val4")
|
||||
.listValues(A_CHANNEL, null);
|
||||
assertThat(columnValueList).hasSize(2);
|
||||
|
||||
columnValueList =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.attachmentReferenceValueLike("%")
|
||||
.listValues(A_REF_VALUE, null);
|
||||
assertThat(columnValueList).hasSize(6);
|
||||
|
||||
columnValueList =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.orderByAttachmentClassificationId(DESCENDING)
|
||||
.listValues(A_CLASSIFICATION_ID, null);
|
||||
assertThat(columnValueList).hasSize(11);
|
||||
|
||||
columnValueList =
|
||||
taskService
|
||||
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 =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(keyDomain)
|
||||
.primaryObjectReferenceCompanyIn("00", "11")
|
||||
|
|
@ -111,7 +160,7 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() {
|
||||
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
|
||||
List<String> attachmentClassificationNames =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(keyDomain)
|
||||
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING);
|
||||
|
|
@ -121,3 +170,4 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
|
|||
null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,19 +23,31 @@ import pro.taskana.task.api.models.TaskSummary;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
||||
|
||||
QueryTasksWithPaginationAccTest() {
|
||||
super();
|
||||
@Nested
|
||||
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")
|
||||
@Test
|
||||
void testGetFirstPageOfTaskQueryWithOffset() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
List<TaskSummary> results =
|
||||
taskService
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
|
||||
.list(0, 10);
|
||||
List<TaskSummary> results = taskService.createTaskQuery().list(0, 10);
|
||||
assertThat(results).hasSize(10);
|
||||
}
|
||||
|
||||
|
|
@ -37,11 +55,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void testSecondPageOfTaskQueryWithOffset() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
List<TaskSummary> results =
|
||||
taskService
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
|
||||
.list(10, 10);
|
||||
List<TaskSummary> results = taskService.createTaskQuery().list(10, 10);
|
||||
assertThat(results).hasSize(10);
|
||||
}
|
||||
|
||||
|
|
@ -51,11 +65,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
|||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
||||
// both will be 0, working
|
||||
List<TaskSummary> results =
|
||||
taskService
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
|
||||
.list(-1, -3);
|
||||
List<TaskSummary> results = taskService.createTaskQuery().list(-1, -3);
|
||||
assertThat(results).isEmpty();
|
||||
|
||||
// limit will be 0
|
||||
|
|
@ -74,7 +84,11 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
|||
.list(-1, 3);
|
||||
assertThat(results).hasSize(3);
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class ListPage {
|
||||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void testPaginationWithPages() {
|
||||
|
|
@ -156,24 +170,19 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
|
|||
.listPage(pageNumber, pageSize);
|
||||
assertThat(results).hasSize(10);
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class Count {
|
||||
@Disabled()
|
||||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void testCountOfTaskQuery() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
long count =
|
||||
taskService
|
||||
.createTaskQuery()
|
||||
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
|
||||
.count();
|
||||
long count = taskService.createTaskQuery().count();
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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,42 +42,19 @@ 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();
|
||||
|
||||
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 TaskId {
|
||||
|
||||
@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();
|
||||
taskService.createTaskQuery().orderByTaskId(SortDirection.DESCENDING).list();
|
||||
|
||||
// test is only valid with at least 2 results
|
||||
assertThat(results).hasSizeGreaterThan(2);
|
||||
|
|
@ -80,12 +74,7 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
@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();
|
||||
List<TaskSummary> results = taskService.createTaskQuery().orderByTaskId(null).list();
|
||||
|
||||
// test is only valid with at least 2 results
|
||||
assertThat(results).hasSizeGreaterThan(2);
|
||||
|
|
@ -97,7 +86,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WorkbasketName {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_sortByWorkbasketNameAsc_When_TaskQueryFilterIsApplied() {
|
||||
|
|
@ -125,7 +118,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
.extracting(WorkbasketSummary::getName)
|
||||
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class Received {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_SortByReceivedAsc_When_TaskQueryFilterIsApplied() {
|
||||
|
|
@ -142,7 +139,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
.extracting(TaskSummary::getReceived)
|
||||
.isSortedAccordingTo(Instant::compareTo);
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class DomainNameAndCreated {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testSortByDomainNameAndCreated() {
|
||||
|
|
@ -162,7 +163,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
.thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER)
|
||||
.thenComparing(TaskSummary::getCreated));
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class PorSystemNoteDueAndOwner {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testSortByPorSystemNoteDueAndOwner() {
|
||||
|
|
@ -192,6 +197,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
previousSummary = taskSummary;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class PorSystemInstanceParentBpiPlannedState {
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
|
|
@ -215,14 +225,19 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
taskSummary
|
||||
.getPrimaryObjRef()
|
||||
.getSystemInstance()
|
||||
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystemInstance())
|
||||
.compareToIgnoreCase(
|
||||
previousSummary.getPrimaryObjRef().getSystemInstance())
|
||||
<= 0)
|
||||
.isTrue();
|
||||
}
|
||||
previousSummary = taskSummary;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class PorCompanyClaimed {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testSortByPorCompanyAndClaimed() {
|
||||
|
|
@ -253,7 +268,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
previousSummary = taskSummary;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WbKeyPriorityPorValueAndCompleted {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void testSortByWbKeyPrioPorValueAndCompleted() {
|
||||
|
|
@ -284,7 +303,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
|
|||
previousSummary = taskSummary;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class BpiClassificationKeyAndPorType {
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue