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

TSK-1282: replaced all usages of Arrays.asList with List.of

This commit is contained in:
Mustapha Zorgati 2020-10-30 02:47:34 +01:00
parent 4f7b1fc867
commit 28b3ce6f8a
49 changed files with 412 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/taskana-common/src/test/java/pro/taskana/common/api/WorkingDaysToDaysConverterTest.java
View File

@ -6,7 +6,7 @@ import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.DynamicContainer;
import org.junit.jupiter.api.DynamicNode;
@ -25,7 +25,7 @@ class WorkingDaysToDaysConverterTest {
CustomHoliday dayOfReformation = CustomHoliday.of(31, 10);
CustomHoliday allSaintsDays = CustomHoliday.of(1, 11);
converter =
new WorkingDaysToDaysConverter(true, false, Arrays.asList(dayOfReformation, allSaintsDays));
new WorkingDaysToDaysConverter(true, false, List.of(dayOfReformation, allSaintsDays));
}
@TestFactory

6
history/taskana-loghistory-provider/src/test/java/pro/taskana/loghistory/impl/LogfileHistoryServiceImplTest.java
View File

@ -57,7 +57,7 @@ class LogfileHistoryServiceImplTest {
logfileHistoryServiceImpl.create(eventToBeLogged);
String logMessage = logger.getLoggingEvents().asList().get(0).getMessage();
String logMessage = logger.getLoggingEvents().get(0).getMessage();
TaskHistoryEvent deserializedEventFromLogMessage =
objectMapper.readValue(logMessage, TaskHistoryEvent.class);
@ -80,7 +80,7 @@ class LogfileHistoryServiceImplTest {
logfileHistoryServiceImpl.create(eventToBeLogged);
String logMessage = logger.getLoggingEvents().asList().get(0).getMessage();
String logMessage = logger.getLoggingEvents().get(0).getMessage();
WorkbasketHistoryEvent deserializedEventFromLogMessage =
objectMapper.readValue(logMessage, WorkbasketHistoryEvent.class);
@ -103,7 +103,7 @@ class LogfileHistoryServiceImplTest {
logfileHistoryServiceImpl.create(eventToBeLogged);
String logMessage = logger.getLoggingEvents().asList().get(0).getMessage();
String logMessage = logger.getLoggingEvents().get(0).getMessage();
ClassificationHistoryEvent deserializedEventFromLogMessage =
objectMapper.readValue(logMessage, ClassificationHistoryEvent.class);

5
history/taskana-simplehistory-provider/src/test/java/acceptance/events/task/DeleteHistoryEventsOnTaskDeletionAccTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -74,7 +73,7 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).hasSize(3);
taskService.deleteTasks(Arrays.asList(taskId_1, taskId_2));
taskService.deleteTasks(List.of(taskId_1, taskId_2));
// make sure the tasks got deleted
ThrowingCallable getDeletedTaskCall =
@ -145,7 +144,7 @@ class DeleteHistoryEventsOnTaskDeletionAccTest extends AbstractAccTest {
historyService.createTaskHistoryQuery().taskIdIn(taskId_1, taskId_2));
assertThat(listEvents).hasSize(2);
taskService.deleteTasks(Arrays.asList(taskId_1, taskId_2));
taskService.deleteTasks(List.of(taskId_1, taskId_2));
// make sure the tasks got deleted
ThrowingCallable getDeletedTaskCall =

3
history/taskana-simplehistory-provider/src/test/java/acceptance/events/workbasket/CreateHistoryEventOnWorkbasketDistributionTargetsSetAccTest.java
View File

@ -3,7 +3,6 @@ package acceptance.events.workbasket;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -33,7 +32,7 @@ class CreateHistoryEventOnWorkbasketDistributionTargetsSetAccTest extends Abstra
final String sourceWorkbasketId = "WBI:100000000000000000000000000000000004";
List<String> targetWorkbaskets =
Arrays.asList(
List.of(
"WBI:100000000000000000000000000000000002", "WBI:100000000000000000000000000000000003");
List<WorkbasketHistoryEvent> events =

19
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskServiceImpl.java
View File

@ -10,6 +10,7 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@ -693,7 +694,7 @@ public class TaskServiceImpl implements TaskService {
List<MinimalTaskSummary> taskSummaries = taskMapper.findExistingTasks(null, externalIds);
Iterator<String> taskIdIterator = externalIds.iterator();
Iterator<String> taskIdIterator = new ArrayList<>(externalIds).iterator();
while (taskIdIterator.hasNext()) {
removeSingleTaskForCallbackStateByExternalId(bulkLog, taskSummaries, taskIdIterator, state);
}
@ -1430,21 +1431,23 @@ public class TaskServiceImpl implements TaskService {
"", new InvalidArgumentException("IDs with EMPTY or NULL value are not allowed."));
externalIdIterator.remove();
} else {
MinimalTaskSummary foundSummary =
Optional<MinimalTaskSummary> foundSummary =
taskSummaries.stream()
.filter(taskSummary -> currentExternalId.equals(taskSummary.getExternalId()))
.findFirst()
.orElse(null);
if (foundSummary == null) {
.findFirst();
if (foundSummary.isPresent()) {
if (!desiredCallbackStateCanBeSetForFoundSummary(
foundSummary.get(), desiredCallbackState)) {
bulkLog.addError(currentExternalId, new InvalidStateException(currentExternalId));
externalIdIterator.remove();
}
} else {
bulkLog.addError(
currentExternalId,
new TaskNotFoundException(
currentExternalId,
String.format("Task with id %s was not found.", currentExternalId)));
externalIdIterator.remove();
} else if (!desiredCallbackStateCanBeSetForFoundSummary(foundSummary, desiredCallbackState)) {
bulkLog.addError(currentExternalId, new InvalidStateException(currentExternalId));
externalIdIterator.remove();
}
}
LOGGER.debug("exit from removeSingleTask()");

365
lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java
View File

@ -7,8 +7,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -188,63 +186,59 @@ class UpdateClassificationAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<String> tasksWithP1D =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000053"));
List.of(
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000053");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithP1D, taskService, converter, 1, 1000);
List<String> tasksWithP8D =
new ArrayList<>(List.of("TKI:000000000000000000000000000000000008"));
List<String> tasksWithP8D = List.of("TKI:000000000000000000000000000000000008");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithP8D, taskService, converter, 8, 1000);
List<String> tasksWithP14D =
new ArrayList<>(List.of("TKI:000000000000000000000000000000000010"));
List<String> tasksWithP14D = List.of("TKI:000000000000000000000000000000000010");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithP14D, taskService, converter, 14, 1000);
List<String> tasksWithP15D =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103"));
List.of(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithP15D, taskService, converter, 15, 1000);
}
@ -294,55 +288,53 @@ class UpdateClassificationAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<String> tasksWithPrio99 =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:200000000000000000000000000000000007",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010"));
List.of(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:200000000000000000000000000000000007",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPrio99, taskService, converter, 1, 99);
List<String> tasksWithPrio101 =
new ArrayList<>(List.of("TKI:000000000000000000000000000000000011"));
List<String> tasksWithPrio101 = List.of("TKI:000000000000000000000000000000000011");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPrio101, taskService, converter, 1, 101);
@ -350,58 +342,56 @@ class UpdateClassificationAccTest extends AbstractAccTest {
updateClassificationAndRunAssociatedJobs(updatedClassification);
List<String> tasksWithPrio7 =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055",
"TKI:200000000000000000000000000000000007"));
List.of(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055",
"TKI:200000000000000000000000000000000007");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPrio7, taskService, converter, 1, 7);
List<String> tasksWithPrio9 =
new ArrayList<>(List.of("TKI:000000000000000000000000000000000008"));
List<String> tasksWithPrio9 = List.of("TKI:000000000000000000000000000000000008");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPrio9, taskService, converter, 1, 9);
tasksWithPrio101 = new ArrayList<>(List.of("TKI:000000000000000000000000000000000011"));
tasksWithPrio101 = List.of("TKI:000000000000000000000000000000000011");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPrio101, taskService, converter, 1, 101);
@ -427,61 +417,58 @@ class UpdateClassificationAccTest extends AbstractAccTest {
// TODO - resume old behaviour after attachment query is possible.
TaskService taskService = taskanaEngine.getTaskService();
List<String> tasksWithPD12 =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:200000000000000000000000000000000007"));
List.of(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103",
"TKI:200000000000000000000000000000000007");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPD12, taskService, converter, 12, 555);
List<String> tasksWithPD8 =
new ArrayList<>(List.of("TKI:000000000000000000000000000000000008"));
List<String> tasksWithPD8 = List.of("TKI:000000000000000000000000000000000008");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPD8, taskService, converter, 8, 555);
List<String> tasksWithPD1 =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055"));
List.of(
"TKI:000000000000000000000000000000000000",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000052",
"TKI:000000000000000000000000000000000053",
"TKI:000000000000000000000000000000000054",
"TKI:000000000000000000000000000000000055");
validateTaskPropertiesAfterClassificationChange(
before, tasksWithPD1, taskService, converter, 1, 555);
}

5
lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java
View File

@ -7,7 +7,6 @@ import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import org.h2.store.fs.FileUtils;
@ -120,7 +119,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
throws Exception {
Path file = Files.createFile(Paths.get(System.getProperty("user.home") + filename));
List<String> lines =
Arrays.asList(
List.of(
"taskana.roles.admin =uSeR " + delimiter + "name=Username,Organisation=novatec",
" taskana.roles.businessadmin = name=user2, ou = bpm " + delimiter + " user3 ",
" taskana.roles.user = ",
@ -139,7 +138,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
private String createNewConfigFileWithSameDelimiter(String filename) throws Exception {
Path file = Files.createFile(Paths.get(System.getProperty("user.home") + filename));
List<String> lines =
Arrays.asList(
List.of(
"taskana.roles.admin =uSeR|Username",
" taskana.roles.businessadmin = user2 | user3 ",
" taskana.roles.user = nobody",

3
lib/taskana-core/src/test/java/acceptance/report/GetCustomAttributeValuesForReportAccTest.java
View File

@ -3,7 +3,6 @@ package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -75,7 +74,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomAttributeValuesForExcludedClassifications() throws Exception {
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<String> domains = List.of("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<String> values =
MONITOR_SERVICE

14
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationCategoryReportAccTest.java
View File

@ -92,7 +92,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
void testGetTaskIdsOfCategoryReport() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE
@ -122,7 +122,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE
@ -146,7 +146,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
final List<TaskState> states = List.of(TaskState.READY);
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE
@ -174,10 +174,10 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithCategoryFilter() throws Exception {
final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
final List<String> categories = List.of("AUTOMATIC", "MANUAL");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE
@ -200,7 +200,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
final List<String> domains = List.of("DOMAIN_A");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE
@ -225,7 +225,7 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
final List<SelectedItem> selectedItems = List.of(EXTERN, AUTOMATIC, MANUAL);
List<String> ids =
MONITOR_SERVICE

14
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationReportAccTest.java
View File

@ -38,7 +38,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@Test
void testRoleCheck() {
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
List<SelectedItem> selectedItems = List.of(L_10000, L_10000_1, L_30000);
ThrowingCallable call =
() ->
@ -70,7 +70,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@Test
void should_SelectCompletedItems_When_CompletedTimeStampIsRequested() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
List<SelectedItem> selectedItems = List.of(L_10000, L_10000_1, L_30000);
List<String> ids =
MONITOR_SERVICE
@ -86,7 +86,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@Test
void testGetTaskIdsOfClassificationReport() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
List<SelectedItem> selectedItems = List.of(L_10000, L_10000_1, L_30000);
List<String> ids =
MONITOR_SERVICE
@ -111,7 +111,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems =
Arrays.asList(
List.of(
new SelectedItem("L10000", "L11000", 0, 0),
new SelectedItem("L10000", "L11000", Integer.MIN_VALUE, -11));
@ -134,7 +134,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems =
Arrays.asList(L_30000, new SelectedItem("L10000", "L11000", 0, 0));
List.of(L_30000, new SelectedItem("L10000", "L11000", 0, 0));
List<String> ids =
MONITOR_SERVICE
@ -152,8 +152,8 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@Test
void testGetTaskIdsOfClassificationReportWithDomainFilter() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
List<String> domains = Arrays.asList("DOMAIN_B", "DOMAIN_C");
List<SelectedItem> selectedItems = List.of(L_10000, L_10000_1, L_30000);
List<String> domains = List.of("DOMAIN_B", "DOMAIN_C");
List<String> ids =
MONITOR_SERVICE

14
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfTaskCustomFieldValueReportAccTest.java
View File

@ -92,7 +92,7 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
void testGetTaskIdsOfCustomFieldValueReport() throws Exception {
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE
@ -119,7 +119,7 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE
@ -141,7 +141,7 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
void testGetTaskIdsOfCustomFieldValueReportWithStateFilter() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE
@ -165,10 +165,10 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithCategoryFilter() throws Exception {
final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
final List<String> categories = List.of("AUTOMATIC", "MANUAL");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE
@ -189,7 +189,7 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
void testGetTaskIdsOfCustomFieldValueReportWithDomainFilter() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE
@ -212,7 +212,7 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List.of(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
List<String> ids =
MONITOR_SERVICE

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

@ -69,7 +69,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
@Test
void should_SelectCompletedItems_When_CompletedTimeStampIsRequested() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
final List<SelectedItem> selectedItems = List.of(S_1, S_2, S_3);
List<String> ids =
MONITOR_SERVICE
@ -85,7 +85,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
@Test
void testGetTaskIdsOfWorkbasketReport() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
final List<SelectedItem> selectedItems = List.of(S_1, S_2, S_3);
List<String> ids =
MONITOR_SERVICE
@ -109,7 +109,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
@Test
void testGetTaskIdsOfWorkbasketReportWithExcludedClassifications() throws Exception {
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
final List<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
final List<SelectedItem> selectedItems = List.of(S_1, S_2, S_3);
List<String> ids =
MONITOR_SERVICE
@ -135,7 +135,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
final List<SelectedItem> selectedItems =
List.of(new SelectedItem("USER-1-1", null, Integer.MIN_VALUE, Integer.MAX_VALUE));
final List<CombinedClassificationFilter> combinedClassificationFilters =
Arrays.asList(
List.of(
new CombinedClassificationFilter(
"CLI:000000000000000000000000000000000003",
"CLI:000000000000000000000000000000000008"),

2
lib/taskana-core/src/test/java/acceptance/report/ProvideClassificationCategoryReportAccTest.java
View File

@ -276,7 +276,7 @@ class ProvideClassificationCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithCategoryFilter() throws Exception {
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> categories = List.of("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationCategoryReport report =

2
lib/taskana-core/src/test/java/acceptance/report/ProvideClassificationReportAccTest.java
View File

@ -307,7 +307,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithCategoryFilter() throws Exception {
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> categories = List.of("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
ClassificationReport report =

2
lib/taskana-core/src/test/java/acceptance/report/ProvideDetailedClassificationReportAccTest.java
View File

@ -500,7 +500,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithCategoryFilter() throws Exception {
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> categories = List.of("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
DetailedClassificationReport report =

2
lib/taskana-core/src/test/java/acceptance/report/ProvideTaskCustomFieldValueReportAccTest.java
View File

@ -292,7 +292,7 @@ class ProvideTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithCategoryFilter() throws Exception {
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> categories = List.of("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
TaskCustomFieldValueReport report =

6
lib/taskana-core/src/test/java/acceptance/report/ProvideTaskStatusReportAccTest.java
View File

@ -1,11 +1,9 @@
package acceptance.report;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
@ -114,7 +112,7 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
TaskStatusReport report =
MONITOR_SERVICE
.createTaskStatusReportBuilder()
.domainIn(asList("DOMAIN_C", "DOMAIN_A"))
.domainIn(List.of("DOMAIN_C", "DOMAIN_A"))
.buildReport();
assertThat(report).isNotNull();
@ -179,7 +177,7 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
MONITOR_SERVICE
.createTaskStatusReportBuilder()
.stateIn(
Arrays.asList(
List.of(
TaskState.READY,
TaskState.CLAIMED,
TaskState.COMPLETED,

11
lib/taskana-core/src/test/java/acceptance/report/ProvideTimestampReportAccTest.java
View File

@ -3,9 +3,8 @@ package acceptance.report;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@ -114,12 +113,10 @@ class ProvideTimestampReportAccTest extends AbstractReportAccTest {
.collect(Collectors.toList());
TimestampReport timestampReport =
MONITOR_SERVICE.createTimestampReportBuilder().withColumnHeaders(headers).buildReport();
final HashSet<String> org1Set = new HashSet<>(Arrays.asList("N/A", "org1"));
final HashSet<String> allOtherOrgLevelSet = new HashSet<>(List.of("N/A"));
final Set<String> org1Set = Set.of("N/A", "org1");
final Set<String> allOtherOrgLevelSet = Set.of("N/A");
assertThat(timestampReport.getRows()).hasSize(2);
assertThat(timestampReport.getRows().keySet())
.isEqualTo(new HashSet<>(Arrays.asList("CREATED", "COMPLETED")));
assertThat(timestampReport.getRows()).containsOnlyKeys("CREATED", "COMPLETED");
// * * * * * * * * * * * * * * * * * * TEST THE CREATED ROW * * * * * * * * * * * * * * * * * *

2
lib/taskana-core/src/test/java/acceptance/report/ProvideWorkbasketReportAccTest.java
View File

@ -260,7 +260,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithCategoryFilter() throws Exception {
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
List<String> categories = List.of("AUTOMATIC", "MANUAL");
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
WorkbasketReport report =

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

@ -1,11 +1,10 @@
package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -98,6 +97,18 @@ class CallbackStateAccTest extends AbstractAccTest {
.hasMessageEndingWith(endOfMessage);
}
@WithAccessId(user = "admin")
@Test
void should_NotThrowUnsupportedOperationException_When_ExternalIdListIsUnmodifiable() {
TaskService taskService = taskanaEngine.getTaskService();
assertThatCode(
() ->
taskService.setCallbackStateForTasks(
List.of(""), CallbackState.CALLBACK_PROCESSING_COMPLETED))
.doesNotThrowAnyException();
}
@WithAccessId(user = "admin")
@Test
void testUpdateOfCallbackState() throws Exception {
@ -127,8 +138,7 @@ class CallbackStateAccTest extends AbstractAccTest {
assertThat(createdTask3.getState()).isEqualTo(TaskState.COMPLETED);
List<String> taskIds =
new ArrayList<>(
Arrays.asList(createdTask1.getId(), createdTask2.getId(), createdTask3.getId()));
List.of(createdTask1.getId(), createdTask2.getId(), createdTask3.getId());
// delete should fail because callback_state = CALLBACK_PROCESSING_REQUIRED
BulkOperationResults<String, TaskanaException> bulkResult1 = taskService.deleteTasks(taskIds);
@ -141,11 +151,10 @@ class CallbackStateAccTest extends AbstractAccTest {
assertThat(excpt.getClass().getName()).isEqualTo(InvalidStateException.class.getName());
}
List<String> externalIds =
new ArrayList<>(
Arrays.asList(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId()));
List.of(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId());
// now enable deletion by setting callback state to CALLBACK_PROCESSING_COMPLETED
BulkOperationResults<String, TaskanaException> bulkResult2 =
@ -153,9 +162,7 @@ class CallbackStateAccTest extends AbstractAccTest {
externalIds, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertThat(bulkResult2.containsErrors()).isFalse();
taskIds =
new ArrayList<>(
Arrays.asList(createdTask1.getId(), createdTask2.getId(), createdTask3.getId()));
taskIds = List.of(createdTask1.getId(), createdTask2.getId(), createdTask3.getId());
// now it should be possible to delete the tasks
BulkOperationResults<String, TaskanaException> bulkResult3 = taskService.deleteTasks(taskIds);
assertThat(bulkResult3.containsErrors()).isFalse();
@ -179,11 +186,10 @@ class CallbackStateAccTest extends AbstractAccTest {
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
Arrays.asList(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId()));
List.of(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId());
// try to set CallbackState to NONE
BulkOperationResults<String, TaskanaException> bulkResult =
@ -213,11 +219,10 @@ class CallbackStateAccTest extends AbstractAccTest {
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
Arrays.asList(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId()));
List.of(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId());
// complete a task
createdTask3 = (TaskImpl) taskService.forceCompleteTask(createdTask3.getId());
@ -250,11 +255,10 @@ class CallbackStateAccTest extends AbstractAccTest {
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
Arrays.asList(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId()));
List.of(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId());
// claim two tasks
createdTask1 = (TaskImpl) taskService.forceClaim(createdTask1.getId());
@ -291,11 +295,10 @@ class CallbackStateAccTest extends AbstractAccTest {
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
Arrays.asList(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId()));
List.of(
createdTask1.getExternalId(),
createdTask2.getExternalId(),
createdTask3.getExternalId());
// It's only allowed to set the CallbackState to REQUIRED if the TaskState doesn't equal
// COMPLETE

16
lib/taskana-core/src/test/java/acceptance/task/CompleteTaskAccTest.java
View File

@ -279,7 +279,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_CompleteAllTasks_When_BulkCompletingTasks() throws Exception {
String id1 = "TKI:000000000000000000000000000000000102";
String id2 = "TKI:000000000000000000000000000000000101";
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
@ -306,7 +306,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_CompleteValidTasksEvenIfErrorsExist_When_BulkCompletingTasks() throws Exception {
String invalid = "invalid-id";
String validId = "TKI:000000000000000000000000000000000103";
List<String> taskIdList = Arrays.asList(invalid, validId);
List<String> taskIdList = List.of(invalid, validId);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
@ -327,6 +327,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
String invalid2 = null;
String invalid3 = "invalid-id";
String notAuthorized = "TKI:000000000000000000000000000000000002";
// we can't use List.of because of the null value we insert
List<String> taskIdList = Arrays.asList(invalid1, invalid2, invalid3, notAuthorized);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
@ -357,7 +358,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_AddErrorForTasksInEndState_When_BulkCompletingTasks() throws Exception {
String id1 = "TKI:300000000000000000000000000000000000"; // task is canceled
String id2 = "TKI:300000000000000000000000000000000010"; // task is terminated
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
BulkOperationResults<String, TaskanaException> results = TASK_SERVICE.completeTasks(taskIdList);
@ -402,7 +403,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_CompleteAllTasks_When_BulkForceCompletingTasks() throws Exception {
String id1 = "TKI:000000000000000000000000000000000026";
String id2 = "TKI:000000000000000000000000000000000027";
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
@ -430,7 +431,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_CompleteValidTasksEvenIfErrorsExist_When_BulkForceCompletingTasks() throws Exception {
String invalid = "invalid-id";
String validId = "TKI:000000000000000000000000000000000028";
List<String> taskIdList = Arrays.asList(invalid, validId);
List<String> taskIdList = List.of(invalid, validId);
Instant beforeBulkComplete = Instant.now().truncatedTo(ChronoUnit.MILLIS);
BulkOperationResults<String, TaskanaException> results =
@ -452,6 +453,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
String invalid2 = null;
String invalid3 = "invalid-id";
String notAuthorized = "TKI:000000000000000000000000000000000002";
// we can't use List.of because of the null value we insert
List<String> taskIdList = Arrays.asList(invalid1, invalid2, invalid3, notAuthorized);
BulkOperationResults<String, TaskanaException> results =
@ -468,7 +470,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_AddErrorForTasksInEndState_When_BulkForceCompletingTasks() throws Exception {
String id1 = "TKI:300000000000000000000000000000000000"; // task is canceled
String id2 = "TKI:300000000000000000000000000000000010"; // task is terminated
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
BulkOperationResults<String, TaskanaException> results =
TASK_SERVICE.forceCompleteTasks(taskIdList);
@ -550,7 +552,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
void should_OnlyClaimTasksWhichAreNotClaimed_When_BulkForceCompletingTasks() throws Exception {
String id1 = "TKI:000000000000000000000000000000000043"; // task is already claimed
String id2 = "TKI:000000000000000000000000000000000044"; // task is ready
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
Task task = TASK_SERVICE.getTask(id2);
assertThat(task.getState()).isSameAs(TaskState.READY);

9
lib/taskana-core/src/test/java/acceptance/task/DeleteTaskAccTest.java
View File

@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -60,7 +59,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
assertThat(
attachmentMapper.findAttachmentSummariesByTaskIds(
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000067",
"TKI:000000000000000000000000000000000068")))
.hasSize(4);
@ -69,14 +68,14 @@ class DeleteTaskAccTest extends AbstractAccTest {
}
taskService.deleteTasks(
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000067",
"TKI:000000000000000000000000000000000068"));
try {
assertThat(
attachmentMapper.findAttachmentSummariesByTaskIds(
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000067",
"TKI:000000000000000000000000000000000068")))
.isEmpty();
@ -129,7 +128,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<String> taskIds =
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000008",

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

@ -261,7 +261,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@TestFactory
Stream<DynamicTest> testQueryForCustomX() {
List<Triplet<TaskCustomField, String[], Integer>> list =
Arrays.asList(
List.of(
new Triplet<>(
TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3),
new Triplet<>(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2),

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

@ -4,9 +4,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -31,8 +29,7 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
void testQueryForWorkbasketKeyDomain() {
TaskService taskService = taskanaEngine.getTaskService();
List<KeyDomain> workbasketIdentifiers =
Arrays.asList(
new KeyDomain("GPK_KSC_2", "DOMAIN_A"), new KeyDomain("USER-1-2", "DOMAIN_A"));
List.of(new KeyDomain("GPK_KSC_2", "DOMAIN_A"), new KeyDomain("USER-1-2", "DOMAIN_A"));
List<TaskSummary> results =
taskService
@ -42,10 +39,7 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
assertThat(results).hasSize(30);
String[] ids =
results.stream()
.map(t -> t.getWorkbasketSummary().getId())
.collect(Collectors.toList())
.toArray(new String[0]);
results.stream().map(t -> t.getWorkbasketSummary().getId()).toArray(String[]::new);
List<TaskSummary> result2 = taskService.createTaskQuery().workbasketIdIn(ids).list();
assertThat(result2).hasSize(30);

11
lib/taskana-core/src/test/java/acceptance/task/ServiceLevelPriorityAccTest.java
View File

@ -9,7 +9,6 @@ import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.assertj.core.data.TemporalUnitWithinOffset;
@ -203,7 +202,7 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
String tkId3 = "TKI:000000000000000000000000000000000058";
String tkId4 = "TKI:000000000000000000000000000000000060";
List<String> taskIds = Arrays.asList(tkId1, tkId2, tkId3, tkId4);
List<String> taskIds = List.of(tkId1, tkId2, tkId3, tkId4);
Instant planned = getInstant("2020-02-11T07:00:00");
BulkOperationResults<String, TaskanaException> results =
@ -230,7 +229,7 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
String tkId3 = "TKI:000000000000000000000000000000000059";
String tkId4 = "TKI:000000000000000000000000000000000058";
String tkId5 = "TKI:000000000000000000000000000000000060";
List<String> taskIds = Arrays.asList(tkId1, tkId2, tkId3, tkId4, tkId5);
List<String> taskIds = List.of(tkId1, tkId2, tkId3, tkId4, tkId5);
Instant planned = getInstant("2020-04-20T07:00:00");
BulkOperationResults<String, TaskanaException> results =
taskService.setPlannedPropertyOfTasks(planned, taskIds);
@ -292,7 +291,7 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
// now check that bulk update gives the same due dates
List<String> taskIds = Arrays.asList(tkId0, tkId1, tkId2);
List<String> taskIds = List.of(tkId0, tkId1, tkId2);
BulkOperationResults<String, TaskanaException> results =
taskService.setPlannedPropertyOfTasks(planned, taskIds);
@ -330,7 +329,7 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
String tkId2 = "TKI:000000000000000000000000000000000009";
String tkId3 = "TKI:000000000000000000000000000000000008";
String tkId4 = "TKI:000000000000000000000000000000000010";
List<String> taskIds = Arrays.asList(tkId1, tkId2, tkId3, tkId4);
List<String> taskIds = List.of(tkId1, tkId2, tkId3, tkId4);
Instant planned = getInstant("2020-02-25T07:00:00");
BulkOperationResults<String, TaskanaException> results =
@ -349,7 +348,7 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
String tkId3 = "TKI:000000000000000000000000000000000008";
String tkId4 = "TKI:000000000000000000000000000000000010"; // all three have P13D
List<String> taskIds = Arrays.asList(tkId1, tkId2, tkId3, tkId4);
List<String> taskIds = List.of(tkId1, tkId2, tkId3, tkId4);
Instant planned = getInstant("2020-05-03T07:00:00");
BulkOperationResults<String, TaskanaException> results =
taskService.setPlannedPropertyOfTasks(planned, taskIds);

7
lib/taskana-core/src/test/java/acceptance/task/SetOwnerAccTest.java
View File

@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map.Entry;
import java.util.stream.Collectors;
@ -98,7 +97,7 @@ class SetOwnerAccTest extends AbstractAccTest {
void testSetOwnerOfTasksWithDuplicatesSucceeds() {
List<String> taskIds =
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000058",
"TKI:000000000000000000000000000000000059",
"TKI:000000000000000000000000000000000058",
@ -112,7 +111,7 @@ class SetOwnerAccTest extends AbstractAccTest {
@Test
void testSetOwnerOfTasksWithDuplicatesAndNotExistingSucceeds() {
List<String> taskIds =
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000058",
"TKI:000000000000000000000000000047110059",
"TKI:000000000000000000000000000000000059",
@ -131,7 +130,7 @@ class SetOwnerAccTest extends AbstractAccTest {
void testSetOwnerOfTasksWithNoQualifyingTasks() {
List<String> taskIds =
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000008",

13
lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java
View File

@ -326,19 +326,18 @@ class TransferTaskAccTest extends AbstractAccTest {
// test with invalid list
ThrowingCallable call =
() -> {
taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
};
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("TaskIds must not be null.");
// test with list containing only invalid arguments
call =
() -> {
taskService.transferTasks(
"WBI:100000000000000000000000000000000006", Arrays.asList("", "", "", null));
};
() ->
taskService.transferTasks(
"WBI:100000000000000000000000000000000006",
/* we can't use List.of because of the null value we insert */
Arrays.asList("", "", "", null));
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("TaskIds must not contain only invalid arguments.");

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

@ -15,7 +15,6 @@ import static pro.taskana.task.api.TaskCustomField.CUSTOM_7;
import acceptance.AbstractAccTest;
import java.time.Instant;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -262,7 +261,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_UpdateTaskCustomAttributes_When_UpdateTasksIsCalled() throws Exception {
List<String> taskIds =
Arrays.asList(
List.of(
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010");

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

@ -7,7 +7,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -201,7 +200,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
String id1 = "TKI:000000000000000000000000000000000102";
String id2 = "TKI:000000000000000000000000000000003333";
List<String> taskIdList = Arrays.asList(id1, id2);
List<String> taskIdList = List.of(id1, id2);
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);

42
lib/taskana-core/src/test/java/acceptance/workbasket/DistributionTargetsAccTest.java
View File

@ -4,8 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@ -36,7 +34,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
WorkbasketSummary workbasketSummary =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
List<String> expectedTargetIds =
Arrays.asList(
List.of(
"WBI:100000000000000000000000000000000002",
"WBI:100000000000000000000000000000000003",
"WBI:100000000000000000000000000000000004",
@ -57,7 +55,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
WorkbasketSummary workbasketSummary =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
List<String> expectedTargetIds =
Arrays.asList(
List.of(
"WBI:100000000000000000000000000000000002",
"WBI:100000000000000000000000000000000003",
"WBI:100000000000000000000000000000000004",
@ -265,16 +263,10 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionSources =
workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
assertThat(distributionSources).hasSize(2);
List<String> expectedIds =
new ArrayList<>(
Arrays.asList(
"WBI:100000000000000000000000000000000001",
"WBI:100000000000000000000000000000000002"));
for (WorkbasketSummary foundSummary : distributionSources) {
assertThat(expectedIds.contains(foundSummary.getId())).isTrue();
}
assertThat(distributionSources)
.extracting(WorkbasketSummary::getId)
.containsExactlyInAnyOrder(
"WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
}
@WithAccessId(user = "teamlead-1")
@ -285,16 +277,10 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionSources =
workbasketService.getDistributionSources("TEAMLEAD-1", "DOMAIN_A");
assertThat(distributionSources).hasSize(2);
List<String> expectedIds =
new ArrayList<>(
Arrays.asList(
"WBI:100000000000000000000000000000000001",
"WBI:100000000000000000000000000000000002"));
for (WorkbasketSummary foundSummary : distributionSources) {
assertThat(expectedIds.contains(foundSummary.getId())).isTrue();
}
assertThat(distributionSources)
.extracting(WorkbasketSummary::getId)
.containsExactlyInAnyOrder(
"WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
}
@WithAccessId(user = "unknownuser")
@ -303,9 +289,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
ThrowingCallable call =
() -> {
workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
};
() -> workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -315,9 +299,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
ThrowingCallable call =
() -> {
workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004");
};
() -> workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004");
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
}

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

@ -323,8 +323,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
.orderByDomain(ASCENDING)
.list();
List<String> expectedIds =
Arrays.asList(
assertThat(results)
.extracting(WorkbasketSummary::getId)
.containsExactlyInAnyOrder(
"WBI:100000000000000000000000000000000001",
"WBI:100000000000000000000000000000000002",
"WBI:100000000000000000000000000000000004",
@ -335,9 +336,6 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000009",
"WBI:100000000000000000000000000000000010",
"WBI:100000000000000000000000000000000012");
assertThat(results)
.extracting(WorkbasketSummary::getId)
.containsExactlyInAnyOrderElementsOf(expectedIds);
}
@WithAccessId(user = "admin")
@ -350,9 +348,10 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
.orderByDomain(DESCENDING)
.list();
assertThat(results).hasSize(2);
assertThat(results.get(0).getId()).isEqualTo("WBI:100000000000000000000000000000000015");
assertThat(results.get(1).getId()).isEqualTo("WBI:100000000000000000000000000000000001");
assertThat(results)
.extracting(WorkbasketSummary::getId)
.containsExactly(
"WBI:100000000000000000000000000000000015", "WBI:100000000000000000000000000000000001");
}
@WithAccessId(user = "teamlead-1")
@ -364,8 +363,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
.customAttributeIn(WorkbasketCustomField.CUSTOM_1, "ABCQVW")
.list();
assertThat(results).hasSize(1);
assertThat(results.get(0).getId()).isEqualTo("WBI:100000000000000000000000000000000001");
assertThat(results)
.extracting(WorkbasketSummary::getId)
.containsExactly("WBI:100000000000000000000000000000000001");
}
@WithAccessId(user = "admin")

11
lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketByPermissionAccTest.java
View File

@ -4,8 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -108,11 +106,10 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.DISTRIBUTE, "user-1-1", GROUP_1_DN)
.list();
assertThat(results).hasSize(2);
List<String> keys = new ArrayList<>(Arrays.asList("GPK_KSC_1", "USER-1-1"));
for (WorkbasketSummary wb : results) {
assertThat(keys.contains(wb.getKey())).isTrue();
}
assertThat(results)
.extracting(WorkbasketSummary::getKey)
.containsExactlyInAnyOrder("GPK_KSC_1", "USER-1-1");
}
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)

3
lib/taskana-core/src/test/java/pro/taskana/ArchitectureTest.java
View File

@ -14,7 +14,6 @@ import com.tngtech.archunit.lang.ArchCondition;
import com.tngtech.archunit.lang.ArchRule;
import com.tngtech.archunit.lang.ConditionEvents;
import com.tngtech.archunit.lang.SimpleConditionEvent;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
@ -31,7 +30,7 @@ import org.junit.jupiter.api.function.ThrowingConsumer;
*/
class ArchitectureTest {
private static final List<String> TASKANA_SUB_PACKAGES =
Arrays.asList(
List.of(
"pro.taskana.sampledata",
"pro.taskana.common.internal",
"pro.taskana.common.api",

11
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java
View File

@ -9,7 +9,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -51,9 +50,9 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfCatgoryReport() throws Exception {
void testGetTotalNumbersOfCategoryReport() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -109,7 +108,7 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
@Test
void testGetCategoryReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -170,7 +169,7 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
@Test
void testListTaskIdsOfCategoryReportForSelectedItems() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -250,7 +249,7 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");

13
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java
View File

@ -10,7 +10,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -67,7 +66,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testGetTotalNumbersOfClassificationReport() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -130,7 +129,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testGetClassificationReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -198,7 +197,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testGetTotalNumbersOfDetailedClassificationReport() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -264,7 +263,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -338,7 +337,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testGetTaskIdsForSelectedItems() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -417,7 +416,7 @@ class ClassificationReportBuilderImplTest {
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");

5
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ReportTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.monitor.internal;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;
@ -127,7 +126,7 @@ class ReportTest {
@Test
void should_AppendItemValue_When_UsingBulkOperationToInsertItems() {
// when
report.addItems(Arrays.asList(item, item));
report.addItems(List.of(item, item));
// then
assertThat(report.getRows()).hasSize(1);
@ -172,7 +171,7 @@ class ReportTest {
return item;
};
// when
report.addItems(Arrays.asList(item, item), preprocessor);
report.addItems(List.of(item, item), preprocessor);
// then
assertThat(report.getRows()).hasSize(1);

7
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/TaskCustomFieldValueReportBuilderImplTest.java
View File

@ -8,7 +8,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -51,7 +50,7 @@ class TaskCustomFieldValueReportBuilderImplTest {
@Test
void testGetTotalNumbersOfCustomFieldValueReport() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -109,7 +108,7 @@ class TaskCustomFieldValueReportBuilderImplTest {
@Test
void testGetCustomFieldValueReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -172,7 +171,7 @@ class TaskCustomFieldValueReportBuilderImplTest {
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");

5
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/TaskStatusReportBuilderImplTest.java
View File

@ -7,7 +7,6 @@ import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
@ -63,7 +62,7 @@ class TaskStatusReportBuilderImplTest {
queryItem2.setCount(30);
queryItem2.setState(TaskState.COMPLETED);
queryItem2.setWorkbasketKey("KEY_1");
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
List<TaskQueryItem> queryItems = List.of(queryItem1, queryItem2);
when(monitorMapperMock.getTasksCountByState(null, null, null)).thenReturn(queryItems);
when(internalTaskanaEngineMock.runAsAdmin(any())).thenReturn(Map.of());
@ -100,7 +99,7 @@ class TaskStatusReportBuilderImplTest {
queryItem2.setCount(30);
queryItem2.setState(TaskState.COMPLETED);
queryItem2.setWorkbasketKey("KEY_1");
List<TaskQueryItem> queryItems = Arrays.asList(queryItem1, queryItem2);
List<TaskQueryItem> queryItems = List.of(queryItem1, queryItem2);
when(monitorMapperMock.getTasksCountByState(eq(null), eq(List.of()), eq(null)))
.thenReturn(queryItems);
when(internalTaskanaEngineMock.runAsAdmin(any())).thenReturn(Map.of());

15
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java
View File

@ -10,7 +10,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -55,7 +54,7 @@ class WorkbasketReportBuilderImplTest {
@Test
void testGetTotalNumbersOfWorkbasketReportBasedOnDueDate() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -111,14 +110,14 @@ class WorkbasketReportBuilderImplTest {
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(actualResult.getSumRow().getTotalValue()).isEqualTo(1);
.isOne();
assertThat(actualResult.getSumRow().getTotalValue()).isOne();
}
@Test
void testGetWorkbasketReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -186,7 +185,7 @@ class WorkbasketReportBuilderImplTest {
@Test
void testGetTaskIdsOfCategoryReportForSelectedItems() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -269,7 +268,7 @@ class WorkbasketReportBuilderImplTest {
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");
@ -331,7 +330,7 @@ class WorkbasketReportBuilderImplTest {
@Test
void testGetTotalNumbersOfWorkbasketReportBasedOnCreatedDate() throws Exception {
final List<String> workbasketIds = List.of("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
final List<TaskState> states = List.of(TaskState.CLAIMED, TaskState.READY);
final List<String> categories = List.of("EXTERN");
final List<String> domains = List.of("DOMAIN_A");
final List<String> classificationIds = List.of("L10000");

3
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkingDaysToDaysReportConverterTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
@ -22,7 +21,7 @@ class WorkingDaysToDaysReportConverterTest {
CustomHoliday dayOfReformation = CustomHoliday.of(31, 10);
CustomHoliday allSaintsDays = CustomHoliday.of(1, 11);
converter =
new WorkingDaysToDaysConverter(true, false, Arrays.asList(dayOfReformation, allSaintsDays));
new WorkingDaysToDaysConverter(true, false, List.of(dayOfReformation, allSaintsDays));
}
@Test

9
lib/taskana-core/src/test/java/pro/taskana/task/internal/models/TaskModelsCloneTest.java
View File

@ -6,7 +6,6 @@ import static pro.taskana.task.internal.CreateTaskModelHelper.createDummyClassif
import static pro.taskana.task.internal.CreateTaskModelHelper.createUnitTestTask;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -74,9 +73,7 @@ class TaskModelsCloneTest {
createUnitTestTask(
"dummyTaskId", "dummyTaskName", "dummyWorkbasketKey", createDummyClassification());
List<Attachment> attachments =
new ArrayList<>(
Arrays.asList(
createAttachment("abc", "dummyTaskId"), createAttachment("def", "dummyTaskId")));
List.of(createAttachment("abc", "dummyTaskId"), createAttachment("def", "dummyTaskId"));
dummyTask.setAttachments(attachments);
TaskImpl dummyTaskCloned = dummyTask.copy();
@ -90,9 +87,7 @@ class TaskModelsCloneTest {
createUnitTestTask(
"dummyTaskId", "dummyTaskName", "workbasketKey", createDummyClassification());
List<Attachment> attachments =
new ArrayList<>(
Arrays.asList(
createAttachment("abc", "dummyTaskId"), createAttachment("def", "dummyTaskId")));
List.of(createAttachment("abc", "dummyTaskId"), createAttachment("def", "dummyTaskId"));
dummyTask.setAttachments(attachments);
TaskImpl dummyTaskCloned = dummyTask.copy();

3
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketServiceImplIntAutocommitTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.workbasket.internal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.List;
import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeAll;
@ -81,7 +80,7 @@ class WorkbasketServiceImplIntAutocommitTest {
createTestWorkbasket(id2, "key2", "DOMAIN_A", "Hyperbasket", WorkbasketType.GROUP);
workbasket2 = workBasketService.createWorkbasket(workbasket2);
createWorkbasketWithSecurity(workbasket2, "user-1-1", true, true, false, false);
List<String> distTargets = Arrays.asList(workbasket0.getId(), workbasket1.getId());
List<String> distTargets = List.of(workbasket0.getId(), workbasket1.getId());
Thread.sleep(SLEEP_TIME);
workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);

3
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketServiceImplIntExplicitTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.workbasket.internal;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.Connection;
import java.util.Arrays;
import java.util.List;
import javax.sql.DataSource;
import org.junit.jupiter.api.AfterEach;
@ -84,7 +83,7 @@ class WorkbasketServiceImplIntExplicitTest {
workbasket2 = workBasketService.createWorkbasket(workbasket2);
createWorkbasketWithSecurity(workbasket2, "user-1-1", true, true, false, false);
List<String> distTargets = Arrays.asList(workbasket0.getId(), workbasket1.getId());
List<String> distTargets = List.of(workbasket0.getId(), workbasket1.getId());
Thread.sleep(SLEEP_TIME);
workBasketService.setDistributionTargets(workbasket2.getId(), distTargets);

79
rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/jobs/AsyncUpdateJobIntTest.java
View File

@ -4,8 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.common.test.rest.RestHelper.TEMPLATE;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
@ -102,45 +100,44 @@ class AsyncUpdateJobIntTest {
assertThat(before).isBefore(modifiedClassification.getModified());
List<String> affectedTasks =
new ArrayList<>(
Arrays.asList(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103"));
List.of(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000007",
"TKI:000000000000000000000000000000000008",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012",
"TKI:000000000000000000000000000000000013",
"TKI:000000000000000000000000000000000014",
"TKI:000000000000000000000000000000000015",
"TKI:000000000000000000000000000000000016",
"TKI:000000000000000000000000000000000017",
"TKI:000000000000000000000000000000000018",
"TKI:000000000000000000000000000000000019",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000021",
"TKI:000000000000000000000000000000000022",
"TKI:000000000000000000000000000000000023",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000025",
"TKI:000000000000000000000000000000000026",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000028",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000030",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000032",
"TKI:000000000000000000000000000000000033",
"TKI:000000000000000000000000000000000034",
"TKI:000000000000000000000000000000000035",
"TKI:000000000000000000000000000000000100",
"TKI:000000000000000000000000000000000101",
"TKI:000000000000000000000000000000000102",
"TKI:000000000000000000000000000000000103");
for (String taskId : affectedTasks) {
verifyTaskIsModifiedAfterOrEquals(taskId, before);
}

16
rest/taskana-rest-spring/src/test/java/pro/taskana/classification/rest/ClassificationDefinitionControllerIntTest.java
View File

@ -10,7 +10,6 @@ import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Order;
@ -201,7 +200,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS, Arrays.asList(classification1, classification2));
TaskanaPagedModelKeys.CLASSIFICATIONS, List.of(classification1, classification2));
ResponseEntity<Void> response = importRequest(clList);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
@ -216,7 +215,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS, Arrays.asList(classification1, classification1));
TaskanaPagedModelKeys.CLASSIFICATIONS, List.of(classification1, classification1));
assertThatThrownBy(() -> importRequest(clList))
.isInstanceOf(HttpClientErrorException.class)
@ -263,7 +262,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS,
Arrays.asList(existingClassification, newClassification));
List.of(existingClassification, newClassification));
ResponseEntity<Void> response = importRequest(clList);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
@ -299,7 +298,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS,
Arrays.asList(
List.of(
classification1,
classification2,
classification3,
@ -335,7 +334,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS, Arrays.asList(parent, wrongParent, child));
TaskanaPagedModelKeys.CLASSIFICATIONS, List.of(parent, wrongParent, child));
ResponseEntity<Void> response = importRequest(clList);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
@ -369,8 +368,7 @@ class ClassificationDefinitionControllerIntTest {
child2.setParentKey("");
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS, Arrays.asList(child1, child2));
new TaskanaPagedModel<>(TaskanaPagedModelKeys.CLASSIFICATIONS, List.of(child1, child2));
ResponseEntity<Void> response = importRequest(clList);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
@ -394,7 +392,7 @@ class ClassificationDefinitionControllerIntTest {
TaskanaPagedModel<ClassificationRepresentationModel> clList =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.CLASSIFICATIONS, Arrays.asList(classification, classification));
TaskanaPagedModelKeys.CLASSIFICATIONS, List.of(classification, classification));
assertThatThrownBy(() -> importRequest(clList))
.isInstanceOf(HttpClientErrorException.class)

11
rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/QueryHelperTest.java
View File

@ -13,7 +13,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static pro.taskana.common.rest.QueryHelper.applyAndRemoveSortingParams;
import java.util.AbstractMap.SimpleEntry;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;
@ -89,7 +88,7 @@ class QueryHelperTest {
@TestFactory
Stream<DynamicTest>
should_CallConsumerWithDescSortDirection_When_MapDoesContainsDescSortDirection() {
Iterator<String> testCases = Arrays.asList("desc", "DESC", "Desc", "desC", "DeSc").iterator();
Iterator<String> testCases = List.of("desc", "DESC", "Desc", "desC", "DeSc").iterator();
ThrowingConsumer<String> test =
desc -> {
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
@ -108,7 +107,7 @@ class QueryHelperTest {
@Test
void should_CallConsumerMultipleTimes_When_MapContainsMultipleSortBy() throws Exception {
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.put(QueryHelper.SORT_BY, Arrays.asList("sort-by-value1", "sort-by-value2"));
map.put(QueryHelper.SORT_BY, List.of("sort-by-value1", "sort-by-value2"));
MockBiConsumer consumer = mock(MockBiConsumer.class);
applyAndRemoveSortingParams(map, consumer);
@ -122,8 +121,8 @@ class QueryHelperTest {
void should_MatchSortDirectionForEachSortBy_When_MapContainsMultipleSortByAndOrderBy()
throws Exception {
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.put(QueryHelper.SORT_BY, Arrays.asList("sort-by-value1", "sort-by-value2"));
map.put(QueryHelper.ORDER_DIRECTION, Arrays.asList("desc", "asc"));
map.put(QueryHelper.SORT_BY, List.of("sort-by-value1", "sort-by-value2"));
map.put(QueryHelper.ORDER_DIRECTION, List.of("desc", "asc"));
MockBiConsumer consumer = mock(MockBiConsumer.class);
applyAndRemoveSortingParams(map, consumer);
@ -143,7 +142,7 @@ class QueryHelperTest {
@Test
void should_ThrowError_When_SortByAndOrderByCountDoesNotMatch() {
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.put(QueryHelper.SORT_BY, Arrays.asList("1", "2"));
map.put(QueryHelper.SORT_BY, List.of("1", "2"));
map.put(QueryHelper.ORDER_DIRECTION, List.of("desc"));
assertThatThrownBy(() -> applyAndRemoveSortingParams(map, mock(MockBiConsumer.class)))
.isInstanceOf(InvalidArgumentException.class);

3
rest/taskana-rest-spring/src/test/java/pro/taskana/workbasket/rest/WorkbasketAccessItemControllerIntTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.test.rest.RestHelper.TEMPLATE;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@ -141,7 +140,7 @@ class WorkbasketAccessItemControllerIntTest {
@TestFactory
Stream<DynamicTest> should_ReturnBadRequest_When_AccessIdIsInvalid() {
List<String> accessIds =
Arrays.asList(
List.of(
"cn=organisationseinheit ksc,cn=organisation,ou=test,o=taskana",
"cn=monitor-users,cn=groups,ou=test,o=taskana",
"user-1");

4
rest/taskana-rest-spring/src/test/java/pro/taskana/workbasket/rest/WorkbasketDefinitionControllerIntTest.java
View File

@ -10,7 +10,6 @@ import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
@ -271,8 +270,7 @@ class WorkbasketDefinitionControllerIntTest {
HttpStatus expectedStatus, WorkbasketDefinitionRepresentationModel... workbaskets)
throws Exception {
TaskanaPagedModel<WorkbasketDefinitionRepresentationModel> pagedModel =
new TaskanaPagedModel<>(
TaskanaPagedModelKeys.WORKBASKET_DEFINITIONS, Arrays.asList(workbaskets));
new TaskanaPagedModel<>(TaskanaPagedModelKeys.WORKBASKET_DEFINITIONS, List.of(workbaskets));
expectStatusWhenExecutingImportRequestOfWorkbaskets(expectedStatus, pagedModel);
}

5
rest/taskana-rest-spring/src/test/java/pro/taskana/workbasket/rest/assembler/WorkbasketDefinitionRepresentationModelAssemblerTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -43,7 +42,7 @@ class WorkbasketDefinitionRepresentationModelAssemblerTest {
String id = "ID1";
workbasket.setId(id);
List<WorkbasketAccessItem> workbasketAccessItems =
Arrays.asList(
List.of(
workbasketService.newWorkbasketAccessItem(id, "a"),
workbasketService.newWorkbasketAccessItem(id, "b"));
@ -51,7 +50,7 @@ class WorkbasketDefinitionRepresentationModelAssemblerTest {
WorkbasketImpl target2 = (WorkbasketImpl) workbasketService.newWorkbasket("3", "DOMAIN_A");
target1.setId("target1");
target2.setId("target2");
List<WorkbasketSummary> workbasketSummaries = Arrays.asList(target1, target2);
List<WorkbasketSummary> workbasketSummaries = List.of(target1, target2);
Mockito.doReturn(workbasketAccessItems).when(workbasketService).getWorkbasketAccessItems(id);
Mockito.doReturn(workbasketSummaries).when(workbasketService).getDistributionTargets(id);