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

TSK-1437: Fixed some SonarCloud Code Smells

This commit is contained in:
SAllhusen 2020-10-27 16:46:52 +01:00 committed by Mustapha Zorgati
parent 04bb137411
commit 4152bf92d0
20 changed files with 115 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common/taskana-common/src/main/java/pro/taskana/common/api/BaseQuery.java
View File

@ -77,6 +77,9 @@ public interface BaseQuery<T, U extends Enum<U> & QueryColumnName> {
default String[] toUpperCopy(String... source) {
if (source == null || source.length == 0) {
// we are currently aware that this is a code smell. Unfortunately the resolution of this
// would cause havoc in our queries, since we do not have a concept
// for a user input validation yet. As soon as that is done we can resolve this code smell.
return null;
} else {
String[] target = new String[source.length];

2
common/taskana-common/src/main/java/pro/taskana/common/api/exceptions/NotFoundException.java
View File

@ -4,7 +4,7 @@ package pro.taskana.common.api.exceptions;
public class NotFoundException extends TaskanaException {
private static final long serialVersionUID = 1L;
String id;
private final String id;
public NotFoundException(String id, String message) {
super(message);

5
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/doc/api/TaskHistoryEventControllerRestDocumentation.java
View File

@ -17,7 +17,6 @@ import pro.taskana.common.test.doc.api.BaseRestDocumentation;
/** Generate documentation for the history event controller. */
class TaskHistoryEventControllerRestDocumentation extends BaseRestDocumentation {
private final HashMap<String, String> taskHistoryEventFieldDescriptionsMap = new HashMap<>();
private FieldDescriptor[] allTaskHistoryEventFieldDescriptors;
@ -119,7 +118,7 @@ class TaskHistoryEventControllerRestDocumentation extends BaseRestDocumentation
}
@Test
public void getAllTaskHistoryEventDocTest() throws Exception {
void getAllTaskHistoryEventDocTest() throws Exception {
this.mockMvc
.perform(
RestDocumentationRequestBuilders.get(
@ -134,7 +133,7 @@ class TaskHistoryEventControllerRestDocumentation extends BaseRestDocumentation
}
@Test
public void getSpecificTaskHistoryEventDocTest() throws Exception {
void getSpecificTaskHistoryEventDocTest() throws Exception {
this.mockMvc
.perform(
RestDocumentationRequestBuilders.get(

4
lib/taskana-core/src/main/java/pro/taskana/classification/internal/jobs/ClassificationChangedJob.java
View File

@ -68,8 +68,8 @@ public class ClassificationChangedJob extends AbstractTaskanaJob {
if (!taskIdBatch.isEmpty()) {
String taskIds = String.join(",", affectedTaskIds);
args.put(TASK_IDS, taskIds);
args.put(PRIORITY_CHANGED, Boolean.valueOf(priorityChanged).toString());
args.put(SERVICE_LEVEL_CHANGED, Boolean.valueOf(serviceLevelChanged).toString());
args.put(PRIORITY_CHANGED, Boolean.toString(priorityChanged));
args.put(SERVICE_LEVEL_CHANGED, Boolean.toString(serviceLevelChanged));
ScheduledJob job = new ScheduledJob();
job.setType(ScheduledJob.Type.UPDATETASKSJOB);
job.setArguments(args);

1
lib/taskana-core/src/main/java/pro/taskana/classification/internal/models/ClassificationImpl.java
View File

@ -137,6 +137,7 @@ public class ClassificationImpl extends ClassificationSummaryImpl implements Cla
return summary;
}
@Override
protected boolean canEqual(Object other) {
return (other instanceof ClassificationImpl);
}

4
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimeIntervalReportBuilderImpl.java
View File

@ -197,8 +197,8 @@ abstract class TimeIntervalReportBuilderImpl<
protected List<CombinedClassificationFilter> getCombinedClassificationFilter() {
// we are currently aware that this is a code smell. Unfortunately the resolution of this would
// cause havoc in our queries, since we do not have a concept for a user validation yet. As soon
// as that is done we can resolve this code smell.
// cause havoc in our queries, since we do not have a concept for a user input validation yet.
// As soon as that is done we can resolve this code smell.
return null;
}

2
lib/taskana-core/src/main/java/pro/taskana/task/internal/jobs/TaskCleanupJob.java
View File

@ -58,7 +58,7 @@ public class TaskCleanupJob extends AbstractTaskanaJob {
try {
List<TaskSummary> tasksCompletedBefore = getTasksCompletedBefore(completedBefore);
int totalNumberOfTasksCompleted = 0;
while (tasksCompletedBefore.size() > 0) {
while (!tasksCompletedBefore.isEmpty()) {
int upperLimit = batchSize;
if (upperLimit > tasksCompletedBefore.size()) {
upperLimit = tasksCompletedBefore.size();

1
lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java
View File

@ -108,7 +108,6 @@ class CreateClassificationAccTest extends AbstractAccTest {
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 1);
assertThat(actual).isNotNull();
assertThat(actual).isSameAs(expected);
assertThat(actual.getIsValidInDomain()).isTrue();
}

2
lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java
View File

@ -35,7 +35,7 @@ class DeleteClassificationAccTest extends AbstractAccTest {
Classification classification = classificationService.getClassification("L140101", "DOMAIN_A");
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
assertThat(classification.getDomain()).isEmpty();
}
@WithAccessId(user = "taskadmin")

14
lib/taskana-core/src/test/java/acceptance/classification/GetClassificationAccTest.java
View File

@ -43,10 +43,10 @@ class GetClassificationAccTest extends AbstractAccTest {
Classification classification = classificationService.getClassification("T6310", "DOMAIN_A");
assertThat(classification).isNotNull();
assertThat(classification.getId()).isEqualTo("CLI:100000000000000000000000000000000011");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getParentId()).isEmpty();
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getIsValidInDomain()).isEqualTo(true);
assertThat(classification.getIsValidInDomain()).isTrue();
assertThat(classification.getName()).isEqualTo("T-GUK Honorarrechnung erstellen");
assertThat(classification.getPriority()).isEqualTo(2);
assertThat(classification.getServiceLevel()).isEqualTo("P2D");
@ -67,11 +67,11 @@ class GetClassificationAccTest extends AbstractAccTest {
classificationService.getClassification("CLI:100000000000000000000000000000000011");
assertThat(classification).isNotNull();
assertThat(classification.getKey()).isEqualTo("T6310");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getParentId()).isEmpty();
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getDomain()).isEqualTo("DOMAIN_A");
assertThat(classification.getIsValidInDomain()).isEqualTo(true);
assertThat(classification.getIsValidInDomain()).isTrue();
assertThat(classification.getName()).isEqualTo("T-GUK Honorarrechnung erstellen");
assertThat(classification.getPriority()).isEqualTo(2);
assertThat(classification.getServiceLevel()).isEqualTo("P2D");
@ -101,7 +101,7 @@ class GetClassificationAccTest extends AbstractAccTest {
.asSummary();
assertThat(classification).isNotNull();
assertThat(classification.getKey()).isEqualTo("T6310");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getParentId()).isEmpty();
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getDomain()).isEqualTo("DOMAIN_A");
@ -136,7 +136,7 @@ class GetClassificationAccTest extends AbstractAccTest {
void testGetOneClassificationForDomainAndGetClassificationFromMasterDomain() throws Exception {
Classification classification = classificationService.getClassification("L10000", "DOMAIN_B");
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
assertThat(classification.getDomain()).isEmpty();
assertThat(classification.getPriority()).isEqualTo(999L);
}
@ -144,7 +144,7 @@ class GetClassificationAccTest extends AbstractAccTest {
void testGetOneClassificationForMasterDomain() throws Exception {
Classification classification = classificationService.getClassification("L10000", "");
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
assertThat(classification.getDomain()).isEmpty();
assertThat(classification.getPriority()).isEqualTo(999L);
}
}

9
lib/taskana-core/src/test/java/acceptance/objectreference/QueryObjectReferenceAccTest.java
View File

@ -14,10 +14,6 @@ import pro.taskana.task.api.models.ObjectReference;
/** Acceptance test for all "get classification" scenarios. */
class QueryObjectReferenceAccTest extends AbstractAccTest {
QueryObjectReferenceAccTest() {
super();
}
@Test
void testQueryObjectReferenceValuesForColumnName() {
TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery();
@ -39,7 +35,6 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().companyIn("Company1", "Company2").list();
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
@ -54,7 +49,6 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
.systemIn("System2")
.list();
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(1);
}
@ -69,7 +63,6 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
.systemInstanceIn("Instance1")
.list();
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(1);
}
@ -80,7 +73,6 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().typeIn("Type2", "Type3").list();
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
@ -91,7 +83,6 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().valueIn("Value1", "Value3").list();
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
}

9
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfWorkbasketReportAccTest.java
View File

@ -121,7 +121,6 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
Collections.singletonList("CLI:000000000000000000000000000000000001"))
.listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
assertThat(ids).hasSize(4);
assertThat(ids)
.containsExactlyInAnyOrder(
"TKI:000000000000000000000000000000000006",
@ -157,10 +156,10 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
assertThat(ids)
.containsExactlyInAnyOrder(
"TKI:000000000000000000000000000000000001", // from second filter
"TKI:000000000000000000000000000000000013", // from second filter
"TKI:000000000000000000000000000000000025", // from first filter
"TKI:000000000000000000000000000000000036", // from first filter
"TKI:000000000000000000000000000000000001", // from second filter
"TKI:000000000000000000000000000000000013", // from second filter
"TKI:000000000000000000000000000000000025", // from first filter
"TKI:000000000000000000000000000000000036", // from first filter
"TKI:000000000000000000000000000000000044"); // from first filter
}

3
lib/taskana-core/src/test/java/acceptance/security/ClassificationQueryAccTest.java
View File

@ -26,7 +26,6 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(18);
}
@ -37,7 +36,6 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(18);
}
@ -48,7 +46,6 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(18);
}
}

4
lib/taskana-core/src/test/java/acceptance/task/CreateTaskCommentAccTest.java
View File

@ -17,10 +17,6 @@ import pro.taskana.task.api.models.TaskComment;
@ExtendWith(JaasExtension.class)
class CreateTaskCommentAccTest extends AbstractAccTest {
CreateTaskCommentAccTest() {
super();
}
@WithAccessId(user = "user-1-2")
@Test
void should_CreateTaskComment_For_TaskComment() throws Exception {

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

@ -40,7 +40,6 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.ownerLike("%user%")
.orderByOwner(desc)
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(8);
}
@ -54,7 +53,6 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.ownerLike("%user%")
.orderByClassificationName(asc)
.listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(5);
}
@ -67,7 +65,6 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
assertThat(tasks).hasSize(1);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).hasSize(2);
tasks =

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

@ -27,10 +27,6 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
private static final Comparator<Object> REFERENCE_COMPARATOR = (o1, o2) -> o1 == o2 ? 0 : -1;
QueryTaskWithAttachmentAccTest() {
super();
}
@WithAccessId(user = "user-1-1")
@Test
void testGetAttachmentSummariesFromTask() {
@ -39,7 +35,6 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
assertThat(tasks).hasSize(1);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).hasSize(2);
}
@ -51,7 +46,6 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
assertThat(tasks).hasSize(30);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).isEmpty();
}

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

@ -94,11 +94,9 @@ class QueryTasksAccTest extends AbstractAccTest {
.ownerLike("%user%")
.orderByOwner(DESCENDING)
.listValues(OWNER, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(3);
columnValueList = taskService.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(5);
}
@ -110,7 +108,6 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(2);
columnValueList =
@ -118,7 +115,6 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.attachmentReferenceValueLike("%")
.listValues(A_REF_VALUE, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(6);
columnValueList =
@ -126,7 +122,6 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(12);
columnValueList =
@ -134,7 +129,6 @@ class QueryTasksAccTest extends AbstractAccTest {
.createTaskQuery()
.orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null);
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(7);
}

4
lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAccTest.java
View File

@ -308,8 +308,8 @@ class UpdateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
assertThat(createdTask.isRead()).isEqualTo(false);
assertThat(createdTask.isTransferred()).isEqualTo(false);
assertThat(createdTask.isRead()).isFalse();
assertThat(createdTask.isTransferred()).isFalse();
Task retrievedTask = taskService.getTask(createdTask.getId());

2
lib/taskana-core/src/test/java/acceptance/workbasket/GetWorkbasketAccTest.java
View File

@ -144,7 +144,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
assertThat(workbasketSummary.getCustomAttribute(CUSTOM_2)).isEqualTo("custom2");
assertThat(workbasketSummary.getCustomAttribute(CUSTOM_3)).isEqualTo("custom3");
assertThat(workbasketSummary.getCustomAttribute(CUSTOM_4)).isEqualTo("custom4");
assertThat(workbasketSummary.isMarkedForDeletion()).isEqualTo(false);
assertThat(workbasketSummary.isMarkedForDeletion()).isFalse();
}
@Test

182
lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccTest.java
View File

@ -11,7 +11,6 @@ import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
@ -31,69 +30,57 @@ import pro.taskana.workbasket.api.models.WorkbasketSummary;
@ExtendWith(JaasExtension.class)
class QueryWorkbasketAccTest extends AbstractAccTest {
private static WorkbasketService workbasketService;
@BeforeAll
static void setup() {
workbasketService = taskanaEngine.getWorkbasketService();
}
private static final WorkbasketService WORKBASKET_SERVICE = taskanaEngine.getWorkbasketService();
@WithAccessId(user = "teamlead-1")
@Test
void testQueryAllForUserMultipleTimes() {
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
WorkbasketQuery query = WORKBASKET_SERVICE.createWorkbasketQuery();
int count = (int) query.count();
assertThat(count).isEqualTo(4);
List<WorkbasketSummary> workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllForBusinessAdminMultipleTimes() {
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
WorkbasketQuery query = WORKBASKET_SERVICE.createWorkbasketQuery();
int count = (int) query.count();
assertThat(count).isEqualTo(25);
List<WorkbasketSummary> workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(user = "admin")
@Test
void testQueryAllForAdminMultipleTimes() {
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
WorkbasketQuery query = WORKBASKET_SERVICE.createWorkbasketQuery();
int count = (int) query.count();
assertThat(count).isEqualTo(25);
List<WorkbasketSummary> workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void testQueryWorkbasketValuesForColumnName() {
List<String> columnValueList = workbasketService.createWorkbasketQuery().listValues(NAME, null);
assertThat(columnValueList).isNotNull();
List<String> columnValueList =
WORKBASKET_SERVICE.createWorkbasketQuery().listValues(NAME, null);
assertThat(columnValueList).hasSize(10);
columnValueList =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("%korb%")
.orderByName(ASCENDING)
.listValues(NAME, DESCENDING); // will override
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(4);
}
@ -101,7 +88,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByDomain() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_B").list();
WORKBASKET_SERVICE.createWorkbasketQuery().domainIn("DOMAIN_B").list();
assertThat(results).hasSize(1);
}
@ -109,7 +96,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByDomainAndType() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.typeIn(WorkbasketType.PERSONAL)
@ -121,7 +108,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByName() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameIn("Gruppenpostkorb KSC").list();
WORKBASKET_SERVICE.createWorkbasketQuery().nameIn("Gruppenpostkorb KSC").list();
assertThat(results)
.hasSize(1)
.first()
@ -133,7 +120,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameStartsWith() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%Gruppenpostkorb KSC%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().nameLike("%Gruppenpostkorb KSC%").list();
assertThat(results).hasSize(3);
}
@ -141,7 +128,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameContains() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("%Teamlead%", "%Gruppenpostkorb KSC%")
.list();
@ -152,7 +139,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameContainsCaseInsensitive() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%TEAMLEAD%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().nameLike("%TEAMLEAD%").list();
assertThat(results).hasSize(2);
}
@ -160,7 +147,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByDescription() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.descriptionLike("%ppk%", "%gruppen%")
.orderByType(DESCENDING)
@ -173,7 +160,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByOwnerLike() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.ownerLike("%an%", "%te%")
.orderByOwner(ASCENDING)
@ -185,7 +172,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByKey() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").list();
WORKBASKET_SERVICE.createWorkbasketQuery().keyIn("GPK_KSC").list();
assertThat(results).hasSize(1);
}
@ -193,7 +180,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByMultipleKeys() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC_1", "GPK_KSC").list();
WORKBASKET_SERVICE.createWorkbasketQuery().keyIn("GPK_KSC_1", "GPK_KSC").list();
assertThat(results).hasSize(2);
}
@ -201,7 +188,10 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByMultipleKeysWithUnknownKey() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC_1", "GPK_Ksc", "GPK_KSC_3").list();
WORKBASKET_SERVICE
.createWorkbasketQuery()
.keyIn("GPK_KSC_1", "GPK_Ksc", "GPK_KSC_3")
.list();
assertThat(results).hasSize(2);
}
@ -209,7 +199,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByKeyContains() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyLike("%KSC%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().keyLike("%KSC%").list();
assertThat(results).hasSize(3);
}
@ -217,7 +207,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByKeyContainsIgnoreCase() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyLike("%kSc%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().keyLike("%kSc%").list();
assertThat(results).hasSize(3);
}
@ -225,7 +215,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByKeyOrNameContainsIgnoreCase() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyOrNameLike("%kSc%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().keyOrNameLike("%kSc%").list();
assertThat(results).hasSize(9);
}
@ -233,7 +223,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameStartsWithSortedByNameAscending() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName(ASCENDING)
@ -248,7 +238,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameStartsWithSortedByNameDescending() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("basxet%")
.orderByName(DESCENDING)
@ -263,7 +253,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameStartsWithSortedByKeyAscending() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(ASCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().nameLike("basxet%").orderByKey(ASCENDING).list();
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getKey)
@ -274,7 +264,11 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByNameStartsWithSortedByKeyDescending() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(DESCENDING).list();
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("basxet%")
.orderByKey(DESCENDING)
.list();
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getKey)
@ -285,7 +279,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByCreated() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().createdWithin(toDaysInterval()).list();
WORKBASKET_SERVICE.createWorkbasketQuery().createdWithin(toDaysInterval()).list();
assertThat(results).hasSize(9);
}
@ -293,7 +287,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByModified() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().modifiedWithin(toDaysInterval()).list();
WORKBASKET_SERVICE.createWorkbasketQuery().modifiedWithin(toDaysInterval()).list();
assertThat(results).hasSize(9);
}
@ -301,14 +295,14 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByAdmin() throws Exception {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").orderByName(DESCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().nameLike("%").orderByName(DESCENDING).list();
assertThat(results)
.hasSize(25)
.extracting(WorkbasketSummary::getName)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(
@ -323,7 +317,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByDomainLike() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.domainLike("DOMAIN_%")
.orderByDomain(ASCENDING)
@ -350,7 +344,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryWorkbasketByOwnerInOrderByDomainDesc() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.ownerIn("owner0815")
.orderByDomain(DESCENDING)
@ -365,7 +359,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom1In() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeIn(WorkbasketCustomField.CUSTOM_1, "ABCQVW")
.list();
@ -378,7 +372,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom1Like() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeLike(WorkbasketCustomField.CUSTOM_1, "custo%")
.list();
@ -389,7 +383,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom2In() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeIn(WorkbasketCustomField.CUSTOM_2, "cust2", "custom2")
.list();
@ -400,7 +394,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom2Like() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeLike(WorkbasketCustomField.CUSTOM_2, "cusTo%")
.list();
@ -411,7 +405,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom3In() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeLike(WorkbasketCustomField.CUSTOM_3, "custom3")
.list();
@ -422,7 +416,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom3Like() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeLike(WorkbasketCustomField.CUSTOM_3, "cu%")
.list();
@ -433,7 +427,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom4In() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeIn(WorkbasketCustomField.CUSTOM_4, "custom4", "team")
.list();
@ -444,7 +438,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForCustom4Like() {
List<WorkbasketSummary> results =
workbasketService
WORKBASKET_SERVICE
.createWorkbasketQuery()
.customAttributeLike(WorkbasketCustomField.CUSTOM_4, "%u%")
.list();
@ -455,7 +449,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevl1In() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel1In("orgl1", "").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel1In("orgl1", "").list();
assertThat(results).hasSize(24);
}
@ -463,7 +457,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel1Like() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel1Like("%1").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel1Like("%1").list();
assertThat(results).hasSize(2);
}
@ -471,7 +465,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel2In() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel2In("abteilung").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel2In("abteilung").list();
assertThat(results).hasSize(1);
}
@ -479,7 +473,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel2Like() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel2Like("ab%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel2Like("ab%").list();
assertThat(results).hasSize(1);
}
@ -487,7 +481,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel3In() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel3In("orgl3").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel3In("orgl3").list();
assertThat(results).hasSize(2);
}
@ -495,7 +489,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel3Like() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel3Like("org%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel3Like("org%").list();
assertThat(results).hasSize(2);
}
@ -503,7 +497,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel4In() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel4In("team", "orgl4").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel4In("team", "orgl4").list();
assertThat(results).hasSize(2);
}
@ -511,7 +505,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrgLevel4Like() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel4Like("%").list();
WORKBASKET_SERVICE.createWorkbasketQuery().orgLevel4Like("%").list();
assertThat(results).hasSize(25);
}
@ -519,7 +513,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByOrgLevel1Desc() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel1(DESCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().orderByOrgLevel1(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -531,7 +525,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByOrgLevel2Asc() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel2(ASCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().orderByOrgLevel2(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -543,7 +537,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByOrgLevel3Desc() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel3(DESCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().orderByOrgLevel3(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -555,7 +549,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@Test
void testQueryForOrderByOrgLevel4Asc() {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel4(ASCENDING).list();
WORKBASKET_SERVICE.createWorkbasketQuery().orderByOrgLevel4(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
@ -566,44 +560,44 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@TestFactory
Stream<DynamicTest> should_SortQueryAsc_When_OrderingByCustomAttribute() {
Iterator<WorkbasketCustomField> iterator = Arrays.stream(WorkbasketCustomField.values())
.iterator();
Iterator<WorkbasketCustomField> iterator =
Arrays.stream(WorkbasketCustomField.values()).iterator();
ThrowingConsumer<WorkbasketCustomField> test = customField -> {
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.orderByCustomAttribute(customField, ASCENDING)
.list();
ThrowingConsumer<WorkbasketCustomField> test =
customField -> {
List<WorkbasketSummary> results =
WORKBASKET_SERVICE
.createWorkbasketQuery()
.orderByCustomAttribute(customField, ASCENDING)
.list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(w -> w.getCustomAttribute(customField))
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
};
return DynamicTest.stream(iterator, c -> "for " + c,
test);
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(w -> w.getCustomAttribute(customField))
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
};
return DynamicTest.stream(iterator, c -> "for " + c, test);
}
@WithAccessId(user = "admin")
@TestFactory
Stream<DynamicTest> should_SortQueryDesc_When_OrderingByCustomAttribute() {
Iterator<WorkbasketCustomField> iterator = Arrays.stream(WorkbasketCustomField.values())
.iterator();
Iterator<WorkbasketCustomField> iterator =
Arrays.stream(WorkbasketCustomField.values()).iterator();
ThrowingConsumer<WorkbasketCustomField> test = customField -> {
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.orderByCustomAttribute(customField, DESCENDING)
.list();
ThrowingConsumer<WorkbasketCustomField> test =
customField -> {
List<WorkbasketSummary> results =
WORKBASKET_SERVICE
.createWorkbasketQuery()
.orderByCustomAttribute(customField, DESCENDING)
.list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(w -> w.getCustomAttribute(customField))
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
};
return DynamicTest.stream(iterator, c -> "for " + c,
test);
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(w -> w.getCustomAttribute(customField))
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
};
return DynamicTest.stream(iterator, c -> "for " + c, test);
}
}