TSK-1267: TimeIntervalReportBuilder#listTaskIdsForSelectedItems now works with TaskTimestamp aswell

history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java

@@ -50,9 +50,13 @@ class QueryHistoryAccTest extends AbstractAccTest {
             .orderByCreated(SortDirection.DESCENDING);
 
     List<HistoryEventImpl> results = query.list();
-    assertThat(results).extracting(TaskanaHistoryEvent::getUserId).containsOnly("admin", "peter");
+    assertThat(results)
+        .extracting(TaskanaHistoryEvent::getUserId)
+        .containsOnly("admin", "peter");
     results = query.orderByUserId(SortDirection.DESCENDING).list();
-    assertThat(results).extracting(TaskanaHistoryEvent::getUserId).containsOnly("admin", "peter");
+    assertThat(results)
+        .extracting(TaskanaHistoryEvent::getUserId)
+        .containsOnly("admin", "peter");
     assertThat(query.domainLike().count()).isEqualTo(13);
   }
 

lib/taskana-core/src/main/java/pro/taskana/monitor/api/SelectedItem.java

@@ -1,46 +1,59 @@
 package pro.taskana.monitor.api;
 
+import java.util.Objects;
+
 /**
  * An item that contains information of a selected item of a Report. It is used to get the task ids
  * of the selected item of the Report.
  */
 public class SelectedItem {
 
-  private String key;
+  private final String key;
-  private String subKey;
+  private final String subKey;
-  private int upperAgeLimit;
+  private final int lowerAgeLimit;
-  private int lowerAgeLimit;
+  private final int upperAgeLimit;
+
+  public SelectedItem(String key, String subKey, int lowerAgeLimit, int upperAgeLimit) {
+    this.key = key;
+    this.subKey = subKey;
+    this.lowerAgeLimit = lowerAgeLimit;
+    this.upperAgeLimit = upperAgeLimit;
+  }
 
   public String getKey() {
     return key;
   }
 
-  public void setKey(String key) {
-    this.key = key;
-  }
-
   public String getSubKey() {
     return subKey;
   }
 
-  public void setSubKey(String subKey) {
-    this.subKey = subKey;
-  }
-
   public int getUpperAgeLimit() {
     return upperAgeLimit;
   }
 
-  public void setUpperAgeLimit(int upperAgeLimit) {
-    this.upperAgeLimit = upperAgeLimit;
-  }
-
   public int getLowerAgeLimit() {
     return lowerAgeLimit;
   }
 
-  public void setLowerAgeLimit(int lowerAgeLimit) {
+  @Override
-    this.lowerAgeLimit = lowerAgeLimit;
+  public int hashCode() {
+    return Objects.hash(key, subKey, upperAgeLimit, lowerAgeLimit);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (this == obj) {
+      return true;
+    }
+    if (!(obj instanceof SelectedItem)) {
+      return false;
+    }
+    SelectedItem other = (SelectedItem) obj;
+    return upperAgeLimit == other.upperAgeLimit
+        && lowerAgeLimit == other.lowerAgeLimit
+        && Objects.equals(key, other.key)
+        && Objects.equals(subKey, other.subKey);
   }
 
   @Override

lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimeIntervalReportBuilder.java

@@ -108,11 +108,13 @@ public interface TimeIntervalReportBuilder<
    * Returns a list of all taskIds of the report that are in the list of selected items.
    *
    * @param selectedItems a list of selectedItems
+   * @param timestamp the task timestamp of interest
    * @return the list of all taskIds
    * @throws InvalidArgumentException if the column headers are not initialized
    * @throws NotAuthorizedException if the user has no rights to access the monitor
    */
-  List<String> listTaskIdsForSelectedItems(List<SelectedItem> selectedItems)
+  List<String> listTaskIdsForSelectedItems(
+      List<SelectedItem> selectedItems, TaskTimestamp timestamp)
       throws NotAuthorizedException, InvalidArgumentException;
 
   /**
@@ -125,6 +127,14 @@ public interface TimeIntervalReportBuilder<
   List<String> listCustomAttributeValuesForCustomAttributeName(TaskCustomField taskCustomField)
       throws NotAuthorizedException;
 
+  /**
+   * Builds the given report.
+   *
+   * @param timestamp The task timestamp of interest
+   * @return The build report
+   * @throws NotAuthorizedException if the user has no rights to access the monitor
+   * @throws InvalidArgumentException when an error occurs
+   */
   Report<I, H> buildReport(TaskTimestamp timestamp)
       throws NotAuthorizedException, InvalidArgumentException;
 }

lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java

@@ -58,7 +58,7 @@ public interface MonitorMapper {
           + "</if>"
           + "</foreach>"
           + "</if>"
-          + "AND T.DUE IS NOT NULL "
+          + "AND T.${timestamp} IS NOT NULL "
           + "</where>"
           + ") AS B "
           + "GROUP BY B.WORKBASKET_KEY, B.AGE_IN_DAYS"
@@ -107,7 +107,7 @@ public interface MonitorMapper {
           + "<if test='customAttributeFilter != null'>"
           + "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
           + "</if>"
-          + "AND DUE IS NOT NULL "
+          + "AND ${timestamp} IS NOT NULL "
           + "</where>"
           + ") AS B "
           + "GROUP BY B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS "
@@ -156,7 +156,7 @@ public interface MonitorMapper {
           + "<if test='customAttributeFilter != null'>"
           + "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
           + "</if>"
-          + "AND DUE IS NOT NULL "
+          + "AND ${timestamp} IS NOT NULL "
           + "</where>"
           + ") AS B "
           + "GROUP BY B.CLASSIFICATION_KEY, B.AGE_IN_DAYS "
@@ -205,7 +205,7 @@ public interface MonitorMapper {
           + "<if test='customAttributeFilter != null'>"
           + "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
           + "</if>"
-          + "AND DUE IS NOT NULL "
+          + "AND T.${timestamp} IS NOT NULL "
           + "</where>"
           + ") AS B "
           + "GROUP BY B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, B.AGE_IN_DAYS "
@@ -255,7 +255,7 @@ public interface MonitorMapper {
           + "<if test='customAttributeFilter != null'>"
           + "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
           + "</if>"
-          + "AND DUE IS NOT NULL "
+          + "AND ${timestamp} IS NOT NULL "
           + "</where>"
           + ") AS B "
           + "GROUP BY B.CUSTOM_FIELD, B.AGE_IN_DAYS "
@@ -304,23 +304,23 @@ public interface MonitorMapper {
           + "<if test='customAttributeFilter != null'>"
           + "AND (<foreach collection='customAttributeFilter.keys' item='key' separator=' AND '>(${key} = '${customAttributeFilter.get(key)}')</foreach>) "
           + "</if>"
-          + "AND T.DUE IS NOT NULL AND ( "
+          + "AND T.${timestamp} IS NOT NULL AND ( "
           + "<foreach collection='selectedItems' item='selectedItem' separator=' OR '>"
           + "#{selectedItem.key} = T.${groupedBy} AND "
           + "<if test=\"joinWithAttachments\">"
           + "A.CLASSIFICATION_KEY = #{selectedItem.subKey} AND "
           + "</if>"
           + "<if test=\"_databaseId == 'db2'\">"
-          + "#{selectedItem.upperAgeLimit} >= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) AND "
+          + "#{selectedItem.upperAgeLimit} >= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) AND "
-          + "#{selectedItem.lowerAgeLimit} &lt;= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) "
+          + "#{selectedItem.lowerAgeLimit} &lt;= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) "
           + "</if> "
           + "<if test=\"_databaseId == 'h2'\">"
-          + "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) AND "
+          + "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) AND "
-          + "#{selectedItem.lowerAgeLimit} &lt;= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) "
+          + "#{selectedItem.lowerAgeLimit} &lt;= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) "
           + "</if> "
           + "<if test=\"_databaseId == 'postgres'\">"
-          + "#{selectedItem.upperAgeLimit} >= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) AND "
+          + "#{selectedItem.upperAgeLimit} >= DATE_PART('day', ${timestamp} - CURRENT_TIMESTAMP ) AND "
-          + "#{selectedItem.lowerAgeLimit} &lt;= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) "
+          + "#{selectedItem.lowerAgeLimit} &lt;= DATE_PART('day', ${timestamp} - CURRENT_TIMESTAMP ) "
           + "</if> "
           + "</foreach>) "
           + "</where>"
@@ -335,6 +335,7 @@ public interface MonitorMapper {
       @Param("excludedClassificationIds") List<String> excludedClassificationIds,
       @Param("customAttributeFilter") Map<TaskCustomField, String> customAttributeFilter,
       @Param("groupedBy") String groupedBy,
+      @Param("timestamp") TaskTimestamp timestamp,
       @Param("selectedItems") List<SelectedItem> selectedItems,
       @Param("joinWithAttachments") boolean joinWithAttachments);
 

lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorServiceImpl.java

@@ -10,7 +10,7 @@ import pro.taskana.monitor.api.reports.TimestampReport;
 import pro.taskana.monitor.api.reports.WorkbasketReport;
 import pro.taskana.monitor.internal.reports.ClassificationCategoryReportBuilderImpl;
 import pro.taskana.monitor.internal.reports.ClassificationReportBuilderImpl;
-import pro.taskana.monitor.internal.reports.CustomFieldValueReportBuilderImpl;
+import pro.taskana.monitor.internal.reports.TaskCustomFieldValueReportBuilderImpl;
 import pro.taskana.monitor.internal.reports.TaskStatusReportBuilderImpl;
 import pro.taskana.monitor.internal.reports.TimestampReportBuilderImpl;
 import pro.taskana.monitor.internal.reports.WorkbasketReportBuilderImpl;
@@ -46,7 +46,7 @@ public class MonitorServiceImpl implements MonitorService {
   @Override
   public TaskCustomFieldValueReport.Builder createTaskCustomFieldValueReportBuilder(
       TaskCustomField taskCustomField) {
-    return new CustomFieldValueReportBuilderImpl(taskanaEngine, monitorMapper, taskCustomField);
+    return new TaskCustomFieldValueReportBuilderImpl(taskanaEngine, monitorMapper, taskCustomField);
   }
 
   @Override

lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TaskCustomFieldValueReportBuilderImpl.java

@@ -18,16 +18,16 @@ import pro.taskana.monitor.internal.preprocessor.DaysToWorkingDaysReportPreProce
 import pro.taskana.task.api.TaskCustomField;
 
 /** The implementation of CustomFieldValueReportBuilder. */
-public class CustomFieldValueReportBuilderImpl
+public class TaskCustomFieldValueReportBuilderImpl
     extends TimeIntervalReportBuilderImpl<Builder, MonitorQueryItem, TimeIntervalColumnHeader>
     implements TaskCustomFieldValueReport.Builder {
 
   private static final Logger LOGGER =
-      LoggerFactory.getLogger(CustomFieldValueReportBuilderImpl.class);
+      LoggerFactory.getLogger(TaskCustomFieldValueReportBuilderImpl.class);
 
   private final TaskCustomField taskCustomField;
 
-  public CustomFieldValueReportBuilderImpl(
+  public TaskCustomFieldValueReportBuilderImpl(
       InternalTaskanaEngine taskanaEngine,
       MonitorMapper monitorMapper,
       TaskCustomField taskCustomField) {

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

@@ -5,6 +5,7 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -14,6 +15,7 @@ import pro.taskana.common.api.exceptions.InvalidArgumentException;
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
 import pro.taskana.common.internal.InternalTaskanaEngine;
 import pro.taskana.monitor.api.SelectedItem;
+import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.ClassificationReport;
 import pro.taskana.monitor.api.reports.TimeIntervalReportBuilder;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@@ -113,7 +115,8 @@ abstract class TimeIntervalReportBuilderImpl<
   }
 
   @Override
-  public List<String> listTaskIdsForSelectedItems(List<SelectedItem> selectedItems)
+  public List<String> listTaskIdsForSelectedItems(
+      List<SelectedItem> selectedItems, TaskTimestamp timestamp)
       throws NotAuthorizedException, InvalidArgumentException {
     if (LOGGER.isDebugEnabled()) {
       LOGGER.debug(
@@ -147,6 +150,7 @@ abstract class TimeIntervalReportBuilderImpl<
           this.excludedClassificationIds,
           this.customAttributeFilter,
           determineGroupedBy(),
+          timestamp,
           selectedItems,
           joinWithAttachments);
     } finally {
@@ -157,8 +161,7 @@ abstract class TimeIntervalReportBuilderImpl<
 
   @Override
   public List<String> listCustomAttributeValuesForCustomAttributeName(
-      TaskCustomField taskCustomField)
+      TaskCustomField taskCustomField) throws NotAuthorizedException {
-      throws NotAuthorizedException {
     LOGGER.debug(
         "entry to listCustomAttributeValuesForCustomAttributeName(customField = {}), this = {}",
         taskCustomField,
@@ -190,13 +193,15 @@ abstract class TimeIntervalReportBuilderImpl<
       List<SelectedItem> selectedItems, List<H> columnHeaders) throws InvalidArgumentException {
     WorkingDaysToDaysReportConverter instance =
         WorkingDaysToDaysReportConverter.initialize(columnHeaders, converter);
-    for (SelectedItem selectedItem : selectedItems) {
+    return selectedItems.stream()
-      selectedItem.setLowerAgeLimit(
+        .map(
-          Collections.min(instance.convertWorkingDaysToDays(selectedItem.getLowerAgeLimit())));
+            s ->
-      selectedItem.setUpperAgeLimit(
+                new SelectedItem(
-          Collections.max(instance.convertWorkingDaysToDays(selectedItem.getUpperAgeLimit())));
+                    s.getKey(),
-    }
+                    s.getSubKey(),
-    return selectedItems;
+                    Collections.min(instance.convertWorkingDaysToDays(s.getLowerAgeLimit())),
+                    Collections.max(instance.convertWorkingDaysToDays(s.getUpperAgeLimit()))))
+        .collect(Collectors.toList());
   }
 
   private boolean subKeyIsSet(List<SelectedItem> selectedItems) {

lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java

@@ -44,7 +44,8 @@ public class TimestampReportBuilderImpl
   }
 
   @Override
-  public List<String> listTaskIdsForSelectedItems(List<SelectedItem> selectedItems) {
+  public List<String> listTaskIdsForSelectedItems(
+      List<SelectedItem> selectedItems, TaskTimestamp timestamp) {
     throw new UnsupportedOperationException();
   }
 

lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java

@@ -36,18 +36,19 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
 
   @Test
   void testDomains() {
-    assertThat(getConfiguration().getDomains()).containsOnly("DOMAIN_A", "DOMAIN_B");
+    assertThat(getConfiguration().getDomains()).containsExactlyInAnyOrder("DOMAIN_A", "DOMAIN_B");
   }
 
   @Test
   void testClassificationTypes() {
-    assertThat(getConfiguration().getClassificationTypes()).containsOnly("TASK", "DOCUMENT");
+    assertThat(getConfiguration().getClassificationTypes())
+        .containsExactlyInAnyOrder("TASK", "DOCUMENT");
   }
 
   @Test
   void testClassificationCategories() {
     assertThat(getConfiguration().getClassificationCategoriesByType("TASK"))
-        .containsOnly("EXTERNAL", "MANUAL", "AUTOMATIC", "PROCESS");
+        .containsExactlyInAnyOrder("EXTERNAL", "MANUAL", "AUTOMATIC", "PROCESS");
   }
 
   @Test

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

@@ -36,7 +36,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
   @Test
   void testStandardConfig() {
     Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
-    assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
+    assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
 
     Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
     assertThat(users)
@@ -73,19 +73,19 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
       getConfiguration().initTaskanaProperties(propertiesFileName, "|");
 
       Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
-      assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
+      assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
 
       Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
-      assertThat(users).containsOnly("nobody");
+      assertThat(users).containsExactly("nobody");
 
       Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
-      assertThat(admins).containsOnly("user", "username");
+      assertThat(admins).containsExactlyInAnyOrder("user", "username");
 
       Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
-      assertThat(businessAdmins).containsOnly("user2", "user3");
+      assertThat(businessAdmins).containsExactlyInAnyOrder("user2", "user3");
 
       Set<String> taskAdmins = getConfiguration().getRoleMap().get(TaskanaRole.TASK_ADMIN);
-      assertThat(taskAdmins).contains("taskadmin");
+      assertThat(taskAdmins).containsExactlyInAnyOrder("taskadmin");
 
     } finally {
       deleteFile(propertiesFileName);
@@ -101,16 +101,16 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
       getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
 
       Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
-      assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
+      assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values());
 
       Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
       assertThat(users).isEmpty();
 
       Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
-      assertThat(admins).containsOnly("user", "name=username,organisation=novatec");
+      assertThat(admins).containsExactlyInAnyOrder("user", "name=username,organisation=novatec");
 
       Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
-      assertThat(businessAdmins).containsOnly("name=user2, ou = bpm", "user3");
+      assertThat(businessAdmins).containsExactlyInAnyOrder("name=user2, ou = bpm", "user3");
 
       Set<String> taskAdmins = getConfiguration().getRoleMap().get(TaskanaRole.TASK_ADMIN);
       assertThat(taskAdmins).contains("taskadmin");

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

@@ -22,39 +22,35 @@ import pro.taskana.task.api.TaskCustomField;
 @ExtendWith(JaasExtension.class)
 class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
 
+  private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
+
   @Test
   void testRoleCheck() {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
     ThrowingCallable call =
-        () -> {
+        () ->
-          monitorService
+            MONITOR_SERVICE
-              .createWorkbasketReportBuilder()
+                .createWorkbasketReportBuilder()
-              .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_2);
+                .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_2);
-        };
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
   @WithAccessId(user = "monitor")
   @Test
   void testGetCustomAttributeValuesForOneWorkbasket() throws Exception {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
     List<String> values =
-        monitorService
+        MONITOR_SERVICE
             .createWorkbasketReportBuilder()
             .workbasketIdIn(Collections.singletonList("WBI:000000000000000000000000000000000001"))
             .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_2);
 
-    assertThat(values).containsOnly("Vollkasko", "Teilkasko");
+    assertThat(values).containsExactlyInAnyOrder("Vollkasko", "Teilkasko");
   }
 
   @WithAccessId(user = "monitor")
   @Test
   void testGetCustomAttributeValuesForOneDomain() throws Exception {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
     List<String> values =
-        monitorService
+        MONITOR_SERVICE
             .createWorkbasketReportBuilder()
             .domainIn(Collections.singletonList("DOMAIN_A"))
             .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_16);
@@ -64,14 +60,12 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
   @WithAccessId(user = "monitor")
   @Test
   void testGetCustomAttributeValuesForCustomAttribute() throws Exception {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
     Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
     customAttributeFilter.put(TaskCustomField.CUSTOM_2, "Vollkasko");
     customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
 
     List<String> values =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .customAttributeFilterIn(customAttributeFilter)
             .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_16);
@@ -82,12 +76,10 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
   @WithAccessId(user = "monitor")
   @Test
   void testGetCustomAttributeValuesForExcludedClassifications() throws Exception {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
     List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
 
     List<String> values =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .domainIn(domains)
             .excludedClassificationIdIn(

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

@@ -1,17 +1,23 @@
 package acceptance.report;
 
 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.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.function.ThrowingConsumer;
 
 import pro.taskana.common.api.exceptions.InvalidArgumentException;
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
@@ -19,6 +25,7 @@ import pro.taskana.common.internal.security.JaasExtension;
 import pro.taskana.common.internal.security.WithAccessId;
 import pro.taskana.monitor.api.MonitorService;
 import pro.taskana.monitor.api.SelectedItem;
+import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
 import pro.taskana.task.api.TaskCustomField;
 import pro.taskana.task.api.TaskState;
@@ -27,56 +34,74 @@ import pro.taskana.task.api.TaskState;
 @ExtendWith(JaasExtension.class)
 class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccTest {
 
+  private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
+
+  private static final SelectedItem EXTERN = new SelectedItem("EXTERN", null, -5, -2);
+  private static final SelectedItem AUTOMATIC =
+      new SelectedItem("AUTOMATIC", null, Integer.MIN_VALUE, -11);
+  private static final SelectedItem MANUAL = new SelectedItem("MANUAL", null, 0, 0);
+
   @Test
   void testRoleCheck() {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
-    List<SelectedItem> selectedItems = new ArrayList<>();
     ThrowingCallable call =
-        () -> {
+        () ->
-          monitorService
+            MONITOR_SERVICE
-              .createClassificationCategoryReportBuilder()
+                .createClassificationCategoryReportBuilder()
-              .listTaskIdsForSelectedItems(selectedItems);
+                .listTaskIdsForSelectedItems(Collections.emptyList(), TaskTimestamp.DUE);
-        };
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
+  @WithAccessId(user = "monitor")
+  @TestFactory
+  Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
+    Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
+
+    ThrowingConsumer<TaskTimestamp> test =
+        timestamp -> {
+          ThrowingCallable callable =
+              () ->
+                  MONITOR_SERVICE
+                      .createClassificationCategoryReportBuilder()
+                      .listTaskIdsForSelectedItems(Collections.singletonList(EXTERN), timestamp);
+          assertThatCode(callable).doesNotThrowAnyException();
+        };
+
+    return DynamicTest.stream(iterator, t -> "for " + t, test);
+  }
+
+  @WithAccessId(user = "monitor")
+  @Test
+  void should_selectCompletedItems_When_CompletedTimeStampIsRequested() throws Exception {
+    final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
+
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
+
+    List<String> ids =
+        MONITOR_SERVICE
+            .createClassificationCategoryReportBuilder()
+            .withColumnHeaders(columnHeaders)
+            .inWorkingDays()
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.COMPLETED);
+
+    assertThat(ids).containsExactly("TKI:000000000000000000000000000000000032");
+  }
+
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReport() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("AUTOMATIC");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("MANUAL");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000020",
             "TKI:000000000000000000000000000000000021",
@@ -93,42 +118,22 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReportWithWorkbasketFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<String> workbasketIds =
         Collections.singletonList("WBI:000000000000000000000000000000000001");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("AUTOMATIC");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("MANUAL");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .workbasketIdIn(workbasketIds)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000020",
             "TKI:000000000000000000000000000000000026",
@@ -138,41 +143,21 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReportWithStateFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TaskState> states = Collections.singletonList(TaskState.READY);
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("AUTOMATIC");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("MANUAL");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .stateIn(states)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000020",
             "TKI:000000000000000000000000000000000021",
@@ -189,35 +174,21 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReportWithCategoryFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("AUTOMATIC");
-    s1.setLowerAgeLimit(Integer.MIN_VALUE);
-    s1.setUpperAgeLimit(-11);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("MANUAL");
-    s2.setLowerAgeLimit(0);
-    s2.setUpperAgeLimit(0);
-    selectedItems.add(s2);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .classificationCategoryIn(categories)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000031",
             "TKI:000000000000000000000000000000000032");
@@ -226,41 +197,21 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReportWithDomainFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<String> domains = Collections.singletonList("DOMAIN_A");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("AUTOMATIC");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("MANUAL");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .domainIn(domains)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000020",
             "TKI:000000000000000000000000000000000021",
             "TKI:000000000000000000000000000000000022",
@@ -270,42 +221,22 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCategoryReportWithCustomFieldValueFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
     customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("AUTOMATIC");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("MANUAL");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationCategoryReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .customAttributeFilterIn(customAttributeFilter)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000020",
             "TKI:000000000000000000000000000000000024",
             "TKI:000000000000000000000000000000000027",
@@ -316,26 +247,17 @@ class GetTaskIdsOfClassificationCategoryReportAccTest extends AbstractReportAccT
   @WithAccessId(user = "monitor")
   @Test
   void testThrowsExceptionIfSubKeysAreUsed() {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems =
-
+        Collections.singletonList(new SelectedItem("EXTERN", "INVALID", -5, -2));
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("EXTERN");
-    s1.setSubKey("INVALID");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
 
     ThrowingCallable call =
-        () -> {
+        () ->
-          monitorService
+            MONITOR_SERVICE
-              .createClassificationCategoryReportBuilder()
+                .createClassificationCategoryReportBuilder()
-              .withColumnHeaders(columnHeaders)
+                .withColumnHeaders(columnHeaders)
-              .listTaskIdsForSelectedItems(selectedItems);
+                .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
-        };
     assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
   }
 

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

@@ -1,94 +1,103 @@
 package acceptance.report;
 
 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.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
+import java.util.stream.Stream;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.function.ThrowingConsumer;
 
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
 import pro.taskana.common.internal.security.JaasExtension;
 import pro.taskana.common.internal.security.WithAccessId;
 import pro.taskana.monitor.api.MonitorService;
 import pro.taskana.monitor.api.SelectedItem;
+import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
 
 /** Acceptance test for all "get task ids of classification report" scenarios. */
 @ExtendWith(JaasExtension.class)
 class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
 
+  private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
+
+  private static final SelectedItem L_10000 = new SelectedItem("L10000", null, 0, 0);
+  private static final SelectedItem L_10000_1 =
+      new SelectedItem("L10000", null, Integer.MIN_VALUE, -11);
+  private static final SelectedItem L_30000 =
+      new SelectedItem("L30000", null, Integer.MIN_VALUE, -11);
+
   @Test
   void testRoleCheck() {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
+    List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
-
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("L10000");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("L10000");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("L30000");
-    s3.setLowerAgeLimit(Integer.MIN_VALUE);
-    s3.setUpperAgeLimit(-11);
-    selectedItems.add(s3);
 
     ThrowingCallable call =
-        () -> {
+        () ->
-          monitorService
+            MONITOR_SERVICE
-              .createClassificationReportBuilder()
+                .createClassificationReportBuilder()
-              .listTaskIdsForSelectedItems(selectedItems);
+                .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
-        };
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
+  @WithAccessId(user = "monitor")
+  @TestFactory
+  Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
+    Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
+
+    ThrowingConsumer<TaskTimestamp> test =
+        timestamp -> {
+          ThrowingCallable callable =
+              () ->
+                  MONITOR_SERVICE
+                      .createClassificationReportBuilder()
+                      .listTaskIdsForSelectedItems(Collections.singletonList(L_10000), timestamp);
+          assertThatCode(callable).doesNotThrowAnyException();
+        };
+
+    return DynamicTest.stream(iterator, t -> "for " + t, test);
+  }
+
+  @WithAccessId(user = "monitor")
+  @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<String> ids =
+        MONITOR_SERVICE
+            .createClassificationReportBuilder()
+            .withColumnHeaders(columnHeaders)
+            .inWorkingDays()
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.COMPLETED);
+
+    assertThat(ids).containsExactlyInAnyOrder("TKI:000000000000000000000000000000000001");
+  }
+
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfClassificationReport() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
+    List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
-    final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("L10000");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("L10000");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("L30000");
-    s3.setLowerAgeLimit(Integer.MIN_VALUE);
-    s3.setUpperAgeLimit(-11);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000001",
             "TKI:000000000000000000000000000000000004",
             "TKI:000000000000000000000000000000000007",
@@ -100,85 +109,42 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfClassificationReportWithAttachments() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
 
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+    final List<SelectedItem> selectedItems =
-
+        Arrays.asList(
-    SelectedItem s1 = new SelectedItem();
+            new SelectedItem("L10000", "L11000", 0, 0),
-    s1.setKey("L10000");
+            new SelectedItem("L10000", "L11000", Integer.MIN_VALUE, -11));
-    s1.setSubKey("L11000");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("L10000");
-    s2.setSubKey("L11000");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("L30000");
-    s3.setLowerAgeLimit(Integer.MIN_VALUE);
-    s3.setUpperAgeLimit(-11);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000001", "TKI:000000000000000000000000000000000033");
   }
 
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfClassificationReportWithDomainFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
+    List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
-    final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
+    List<String> domains = Arrays.asList("DOMAIN_B", "DOMAIN_C");
-
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("L10000");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("L10000");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("L30000");
-    s3.setLowerAgeLimit(Integer.MIN_VALUE);
-    s3.setUpperAgeLimit(-11);
-    selectedItems.add(s3);
-
-    List<String> domains = new ArrayList<>();
-    domains.add("DOMAIN_B");
-    domains.add("DOMAIN_C");
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createClassificationReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .domainIn(domains)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000001",
             "TKI:000000000000000000000000000000000004",
             "TKI:000000000000000000000000000000000006");

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

@@ -1,17 +1,23 @@
 package acceptance.report;
 
 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.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Stream;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.function.ThrowingConsumer;
 
 import pro.taskana.common.api.exceptions.InvalidArgumentException;
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
@@ -19,6 +25,7 @@ import pro.taskana.common.internal.security.JaasExtension;
 import pro.taskana.common.internal.security.WithAccessId;
 import pro.taskana.monitor.api.MonitorService;
 import pro.taskana.monitor.api.SelectedItem;
+import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
 import pro.taskana.task.api.TaskCustomField;
 import pro.taskana.task.api.TaskState;
@@ -27,56 +34,77 @@ import pro.taskana.task.api.TaskState;
 @ExtendWith(JaasExtension.class)
 class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTest {
 
+  private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
+
+  private static final SelectedItem GESCHAEFTSSTELLE_A =
+      new SelectedItem("Geschaeftsstelle A", null, -5, -2);
+  private static final SelectedItem GESCHAEFTSSTELLE_B =
+      new SelectedItem("Geschaeftsstelle B", null, Integer.MIN_VALUE, -11);
+  private static final SelectedItem GESCHAEFTSSTELLE_C =
+      new SelectedItem("Geschaeftsstelle C", null, 0, 0);
+
   @Test
   void testRoleCheck() {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
-    List<SelectedItem> selectedItems = new ArrayList<>();
-
     ThrowingCallable call =
         () ->
-            monitorService
+            MONITOR_SERVICE
                 .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
-                .listTaskIdsForSelectedItems(selectedItems);
+                .listTaskIdsForSelectedItems(Collections.emptyList(), TaskTimestamp.DUE);
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
+  @WithAccessId(user = "monitor")
+  @TestFactory
+  Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
+    Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
+
+    ThrowingConsumer<TaskTimestamp> test =
+        timestamp -> {
+          ThrowingCallable callable =
+              () ->
+                  MONITOR_SERVICE
+                      .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
+                      .listTaskIdsForSelectedItems(
+                          Collections.singletonList(GESCHAEFTSSTELLE_A), timestamp);
+          assertThatCode(callable).doesNotThrowAnyException();
+        };
+
+    return DynamicTest.stream(iterator, t -> "for " + t, test);
+  }
+
+  @WithAccessId(user = "monitor")
+  @Test
+  void should_selectCompletedItems_When_CompletedTimeStampIsRequested() throws Exception {
+    List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
+    List<SelectedItem> selectedItems =
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
+
+    List<String> ids =
+        MONITOR_SERVICE
+            .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
+            .withColumnHeaders(columnHeaders)
+            .inWorkingDays()
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.COMPLETED);
+
+    assertThat(ids).containsExactly("TKI:000000000000000000000000000000000029");
+  }
+
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReport() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
+    List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000002",
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000009",
@@ -90,42 +118,22 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReportWithWorkbasketFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<String> workbasketIds =
         Collections.singletonList("WBI:000000000000000000000000000000000001");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .workbasketIdIn(workbasketIds)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000009",
             "TKI:000000000000000000000000000000000020");
@@ -134,37 +142,17 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReportWithStateFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .stateIn(Collections.singletonList(TaskState.READY))
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids).hasSize(8);
     assertThat(ids.contains("TKI:000000000000000000000000000000000002")).isTrue();
@@ -180,38 +168,18 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReportWithCategoryFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .classificationCategoryIn(categories)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids).hasSize(3);
     assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
@@ -222,37 +190,17 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReportWithDomainFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .domainIn(Collections.singletonList("DOMAIN_A"))
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids).hasSize(3);
     assertThat(ids.contains("TKI:000000000000000000000000000000000009")).isTrue();
@@ -263,39 +211,19 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final Map<TaskCustomField, String> customAttributeFilter = new HashMap<>();
     customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A");
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("Geschaeftsstelle B");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("Geschaeftsstelle C");
-    s3.setLowerAgeLimit(0);
-    s3.setUpperAgeLimit(0);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createTaskCustomFieldValueReportBuilder(TaskCustomField.CUSTOM_1)
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .customAttributeFilterIn(customAttributeFilter)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids).hasSize(4);
     assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
@@ -307,25 +235,16 @@ class GetTaskIdsOfTaskCustomFieldValueReportAccTest extends AbstractReportAccTes
   @WithAccessId(user = "monitor")
   @Test
   void testThrowsExceptionIfSubKeysAreUsed() {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    final List<SelectedItem> selectedItems =
-    final List<SelectedItem> selectedItems = new ArrayList<>();
+        Collections.singletonList(new SelectedItem("Geschaeftsstelle A", "INVALID", -5, -2));
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("Geschaeftsstelle A");
-    s1.setSubKey("INVALID");
-    s1.setLowerAgeLimit(-5);
-    s1.setUpperAgeLimit(-2);
-    selectedItems.add(s1);
 
     ThrowingCallable call =
         () ->
-            monitorService
+            MONITOR_SERVICE
                 .createClassificationCategoryReportBuilder()
                 .withColumnHeaders(columnHeaders)
-                .listTaskIdsForSelectedItems(selectedItems);
+                .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
     assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
   }
 

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

@@ -1,75 +1,101 @@
 package acceptance.report;
 
 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.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
+import java.util.stream.Stream;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestFactory;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.function.ThrowingConsumer;
 
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
 import pro.taskana.common.internal.security.JaasExtension;
 import pro.taskana.common.internal.security.WithAccessId;
 import pro.taskana.monitor.api.MonitorService;
 import pro.taskana.monitor.api.SelectedItem;
+import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
 
 /** Acceptance test for all "get task ids of workbasket report" scenarios. */
 @ExtendWith(JaasExtension.class)
 class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
 
+  private static final MonitorService MONITOR_SERVICE = taskanaEngine.getMonitorService();
+
+  private static final SelectedItem S_1 = new SelectedItem("USER-1-1", null, 0, 0);
+  private static final SelectedItem S_2 =
+      new SelectedItem("USER-1-1", null, Integer.MIN_VALUE, -11);
+  private static final SelectedItem S_3 =
+      new SelectedItem("USER-1-2", null, 1000, Integer.MAX_VALUE);
+
   @Test
   void testRoleCheck() {
-    MonitorService monitorService = taskanaEngine.getMonitorService();
-
-    List<SelectedItem> selectedItems = new ArrayList<>();
-
     ThrowingCallable call =
-        () -> {
+        () ->
-          monitorService.createWorkbasketReportBuilder().listTaskIdsForSelectedItems(selectedItems);
+            MONITOR_SERVICE
-        };
+                .createWorkbasketReportBuilder()
+                .listTaskIdsForSelectedItems(Collections.emptyList(), TaskTimestamp.DUE);
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
+  @WithAccessId(user = "monitor")
+  @TestFactory
+  Stream<DynamicTest> should_NotThrowError_When_buildReportForTaskState() {
+    Iterator<TaskTimestamp> iterator = Arrays.stream(TaskTimestamp.values()).iterator();
+
+    ThrowingConsumer<TaskTimestamp> test =
+        timestamp -> {
+          ThrowingCallable callable =
+              () ->
+                  MONITOR_SERVICE
+                      .createWorkbasketReportBuilder()
+                      .listTaskIdsForSelectedItems(Collections.singletonList(S_1), timestamp);
+          assertThatCode(callable).doesNotThrowAnyException();
+        };
+
+    return DynamicTest.stream(iterator, t -> "for " + t, test);
+  }
+
+  @WithAccessId(user = "monitor")
+  @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);
+
+    List<String> ids =
+        MONITOR_SERVICE
+            .createWorkbasketReportBuilder()
+            .withColumnHeaders(columnHeaders)
+            .inWorkingDays()
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.COMPLETED);
+
+    assertThat(ids).containsExactlyInAnyOrder("TKI:000000000000000000000000000000000001");
+  }
+
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfWorkbasketReport() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    final List<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("USER-1-1");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("USER-1-1");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("USER-1-2");
-    s3.setLowerAgeLimit(1000);
-    s3.setUpperAgeLimit(Integer.MAX_VALUE);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createWorkbasketReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000001",
             "TKI:000000000000000000000000000000000004",
             "TKI:000000000000000000000000000000000006",
@@ -82,42 +108,21 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
   @WithAccessId(user = "monitor")
   @Test
   void testGetTaskIdsOfWorkbasketReportWithExcludedClassifications() throws Exception {
-    final MonitorService monitorService = taskanaEngine.getMonitorService();
-
     final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
-
+    final List<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
-    final List<SelectedItem> selectedItems = new ArrayList<>();
-
-    SelectedItem s1 = new SelectedItem();
-    s1.setKey("USER-1-1");
-    s1.setLowerAgeLimit(0);
-    s1.setUpperAgeLimit(0);
-    selectedItems.add(s1);
-
-    SelectedItem s2 = new SelectedItem();
-    s2.setKey("USER-1-1");
-    s2.setLowerAgeLimit(Integer.MIN_VALUE);
-    s2.setUpperAgeLimit(-11);
-    selectedItems.add(s2);
-
-    SelectedItem s3 = new SelectedItem();
-    s3.setKey("USER-1-2");
-    s3.setLowerAgeLimit(1000);
-    s3.setUpperAgeLimit(Integer.MAX_VALUE);
-    selectedItems.add(s3);
 
     List<String> ids =
-        monitorService
+        MONITOR_SERVICE
             .createWorkbasketReportBuilder()
             .withColumnHeaders(columnHeaders)
             .inWorkingDays()
             .excludedClassificationIdIn(
                 Collections.singletonList("CLI:000000000000000000000000000000000001"))
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     assertThat(ids).hasSize(4);
     assertThat(ids)
-        .containsOnly(
+        .containsExactlyInAnyOrder(
             "TKI:000000000000000000000000000000000006",
             "TKI:000000000000000000000000000000000009",
             "TKI:000000000000000000000000000000000031",

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

@@ -270,7 +270,7 @@ class CallbackStateAccTest extends AbstractAccTest {
     assertThat(failedTaskIds)
         .hasSize(2)
         .doesNotContain(createdTask1.getExternalId())
-        .containsOnly(createdTask2.getExternalId(), createdTask3.getExternalId());
+        .containsExactlyInAnyOrder(createdTask2.getExternalId(), createdTask3.getExternalId());
   }
 
   @WithAccessId(user = "admin")
@@ -305,7 +305,7 @@ class CallbackStateAccTest extends AbstractAccTest {
             externalIds, CallbackState.CALLBACK_PROCESSING_REQUIRED);
     assertThat(bulkResult.containsErrors()).isTrue();
     List<String> failedTaskIds = bulkResult.getFailedIds();
-    assertThat(failedTaskIds).containsOnly(createdTask3.getExternalId());
+    assertThat(failedTaskIds).containsExactlyInAnyOrder(createdTask3.getExternalId());
   }
 
   @WithAccessId(user = "admin")

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

@@ -53,7 +53,7 @@ class CreateTaskAccTest extends AbstractAccTest {
     assertThat(newTask.getId()).isNotEqualTo(oldTask.getId());
     assertThat(newTask.getAttachments())
         .extracting(AttachmentSummary::getTaskId)
-        .containsOnly(newTask.getId());
+        .contains(newTask.getId());
   }
 
   @WithAccessId(user = "user-1-1")

lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java

@@ -76,7 +76,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
         .hasSize(attachmentCount + 1)
         .contains(attachment)
         .extracting(Attachment::getModified)
-        .containsOnly(task.getModified());
+        .containsExactlyInAnyOrder(task.getModified());
   }
 
   @WithAccessId(user = "user-1-1")
@@ -96,7 +96,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
     assertThat(task.getAttachments())
         .hasSize(1)
         .extracting(AttachmentSummary::getModified)
-        .containsOnly(task.getModified());
+        .containsExactlyInAnyOrder(task.getModified());
   }
 
   @WithAccessId(user = "user-1-1")

lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccessItemsAccTest.java

@@ -170,7 +170,9 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
     };
     List<WorkbasketAccessItem> results =
         workbasketService.createWorkbasketAccessItemQuery().idIn(expectedIds).list();
-    assertThat(results).extracting(WorkbasketAccessItem::getId).containsOnly(expectedIds);
+    assertThat(results)
+        .extracting(WorkbasketAccessItem::getId)
+        .containsExactlyInAnyOrder(expectedIds);
   }
 
   @WithAccessId(user = "businessadmin")

lib/taskana-core/src/test/java/pro/taskana/common/internal/security/JaasExtensionTest.java

@@ -144,7 +144,7 @@ class JaasExtensionTest {
   @Test
   void should_SetJaasSubjectWithGroups_When_AnnotationExistsWithGroups_On_Test() {
     assertThat(CurrentUserContext.getUserid()).isEqualTo("user");
-    assertThat(CurrentUserContext.getGroupIds()).containsOnly("group1", "group2");
+    assertThat(CurrentUserContext.getGroupIds()).containsExactlyInAnyOrder("group1", "group2");
   }
 
   @WithAccessId(user = "user")
@@ -217,7 +217,7 @@ class JaasExtensionTest {
   @TestTemplate
   void should_InjectCorrectAccessId_When_AnnotationExists_On_TestTemplate(WithAccessId accessId) {
     assertThat(accessId.user()).isEqualTo("testtemplate1");
-    assertThat(accessId.groups()).containsOnly("abc");
+    assertThat(accessId.groups()).containsExactly("abc");
   }
 
   // endregion

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

@@ -184,11 +184,8 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
+    List<SelectedItem> selectedItems =
-    selectedItem.setKey("EXTERN");
+        Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-    List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
 
     List<String> expectedResult =
         Collections.singletonList("TKI:000000000000000000000000000000000001");
@@ -201,6 +198,7 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
             excludedClassificationIds,
             customAttributeFilter,
             "CLASSIFICATION_CATEGORY",
+            TaskTimestamp.DUE,
             selectedItems,
             false))
         .thenReturn(expectedResult);
@@ -215,7 +213,7 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
             .excludedClassificationIdIn(excludedClassificationIds)
             .customAttributeFilterIn(customAttributeFilter)
             .withColumnHeaders(columnHeaders)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     verify(internalTaskanaEngineMock).openConnection();
     verify(internalTaskanaEngineMock, times(2)).getEngine();
@@ -223,7 +221,17 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
     verify(taskanaEngineMock).getWorkingDaysToDaysConverter();
     verify(monitorMapperMock)
         .getTaskIdsForSelectedItems(
-            any(), any(), any(), any(), any(), any(), any(), any(), any(), eq(false));
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            eq(TaskTimestamp.DUE),
+            any(),
+            eq(false));
     verify(internalTaskanaEngineMock).returnConnection();
     verifyNoMoreInteractions(
         internalTaskanaEngineMock,
@@ -236,10 +244,10 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
 
   @Test
   void testListTaskIdsForSelectedItemsIsEmptyResult() throws Exception {
-    SelectedItem selectedItem = new SelectedItem();
-    List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
     List<String> result =
-        cut.createClassificationCategoryReportBuilder().listTaskIdsForSelectedItems(selectedItems);
+        cut.createClassificationCategoryReportBuilder()
+            .listTaskIdsForSelectedItems(
+                Collections.singletonList(new SelectedItem("BLA", null, 0, 0)), TaskTimestamp.DUE);
     assertThat(result).isNotNull();
   }
 
@@ -257,11 +265,6 @@ class ClassificationClassificationCategoryReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
-    selectedItem.setKey("EXTERN");
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-
     List<String> expectedResult = Collections.singletonList("Geschaeftsstelle A");
     when(monitorMapperMock.getCustomAttributeValuesForReport(
             workbasketIds,

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

@@ -354,11 +354,8 @@ class ClassificationReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
+    final List<SelectedItem> selectedItems =
-    selectedItem.setKey("EXTERN");
+        Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-    final List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
 
     final List<String> expectedResult =
         Collections.singletonList("TKI:000000000000000000000000000000000001");
@@ -371,6 +368,7 @@ class ClassificationReportBuilderImplTest {
             excludedClassificationIds,
             customAttributeFilter,
             "CLASSIFICATION_KEY",
+            TaskTimestamp.DUE,
             selectedItems,
             false))
         .thenReturn(expectedResult);
@@ -385,7 +383,7 @@ class ClassificationReportBuilderImplTest {
             .excludedClassificationIdIn(excludedClassificationIds)
             .customAttributeFilterIn(customAttributeFilter)
             .withColumnHeaders(columnHeaders)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     verify(internalTaskanaEngineMock).openConnection();
     verify(taskanaEngineMock).checkRoleMembership(any());
@@ -394,24 +392,32 @@ class ClassificationReportBuilderImplTest {
 
     verify(monitorMapperMock)
         .getTaskIdsForSelectedItems(
-            any(), any(), any(), any(), any(), any(), any(), any(), any(), eq(false));
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            eq(TaskTimestamp.DUE),
+            any(),
+            eq(false));
     verify(internalTaskanaEngineMock).returnConnection();
     verify(taskanaEngineMock).getClassificationService();
     verifyNoMoreInteractions(mocks);
 
-    assertThat(actualResult).isNotNull();
     assertThat(actualResult).isEqualTo(expectedResult);
   }
 
   @Test
   void testGetTaskIdsForSelectedItemsIsEmptyResult() throws Exception {
-    SelectedItem selectedItem = new SelectedItem();
+    List<SelectedItem> selectedItems =
-    selectedItem.setKey("GIBTSNED");
+        Collections.singletonList(new SelectedItem("GIBTSNED", null, 0, 0));
-    List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
     List<String> result =
         cut.createClassificationReportBuilder()
             .workbasketIdIn(Collections.singletonList("DieGibtsEhNed"))
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
     assertThat(result).isNotNull();
   }
 
@@ -429,11 +435,6 @@ class ClassificationReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
-    selectedItem.setKey("EXTERN");
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-
     final List<String> expectedResult = Collections.singletonList("Geschaeftsstelle A");
     when(monitorMapperMock.getCustomAttributeValuesForReport(
             workbasketIds,

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

@@ -23,7 +23,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
 import pro.taskana.TaskanaEngineConfiguration;
 import pro.taskana.common.api.TaskanaEngine;
 import pro.taskana.common.internal.InternalTaskanaEngine;
-import pro.taskana.monitor.api.SelectedItem;
 import pro.taskana.monitor.api.TaskTimestamp;
 import pro.taskana.monitor.api.reports.TaskCustomFieldValueReport;
 import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
@@ -187,11 +186,6 @@ class TaskCustomFieldValueReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
-    selectedItem.setKey("EXTERN");
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-
     List<String> expectedResult = Collections.singletonList("Geschaeftsstelle A");
     when(monitorMapperMock.getCustomAttributeValuesForReport(
             workbasketIds,

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

@@ -200,11 +200,8 @@ class WorkbasketReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
+    List<SelectedItem> selectedItems =
-    selectedItem.setKey("EXTERN");
+        Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-    List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
 
     List<String> expectedResult =
         Collections.singletonList("TKI:000000000000000000000000000000000001");
@@ -217,6 +214,7 @@ class WorkbasketReportBuilderImplTest {
             excludedClassificationIds,
             customAttributeFilter,
             "WORKBASKET_KEY",
+            TaskTimestamp.DUE,
             selectedItems,
             false))
         .thenReturn(expectedResult);
@@ -231,7 +229,7 @@ class WorkbasketReportBuilderImplTest {
             .excludedClassificationIdIn(excludedClassificationIds)
             .customAttributeFilterIn(customAttributeFilter)
             .withColumnHeaders(columnHeaders)
-            .listTaskIdsForSelectedItems(selectedItems);
+            .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
 
     verify(internalTaskanaEngineMock).openConnection();
     verify(taskanaEngineMock).checkRoleMembership(any());
@@ -239,7 +237,17 @@ class WorkbasketReportBuilderImplTest {
     verify(internalTaskanaEngineMock, times(3)).getEngine();
     verify(monitorMapperMock)
         .getTaskIdsForSelectedItems(
-            any(), any(), any(), any(), any(), any(), any(), any(), any(), eq(false));
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            any(),
+            eq(TaskTimestamp.DUE),
+            any(),
+            eq(false));
     verify(internalTaskanaEngineMock).returnConnection();
     verify(taskanaEngineMock).getWorkbasketService();
     verifyNoMoreInteractions(internalTaskanaEngineMock, taskanaEngineMock, monitorMapperMock);
@@ -256,7 +264,7 @@ class WorkbasketReportBuilderImplTest {
           List<String> result =
               cut.createWorkbasketReportBuilder()
                   .workbasketIdIn(Collections.singletonList("DieGibtsGarantiertNed"))
-                  .listTaskIdsForSelectedItems(selectedItems);
+                  .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE);
           assertThat(result).isNotNull();
         };
     assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
@@ -276,11 +284,6 @@ class WorkbasketReportBuilderImplTest {
     final List<TimeIntervalColumnHeader> columnHeaders =
         Collections.singletonList(new TimeIntervalColumnHeader(0, 0));
 
-    SelectedItem selectedItem = new SelectedItem();
-    selectedItem.setKey("EXTERN");
-    selectedItem.setLowerAgeLimit(1);
-    selectedItem.setUpperAgeLimit(5);
-
     List<String> expectedResult = Collections.singletonList("Geschaeftsstelle A");
     when(monitorMapperMock.getCustomAttributeValuesForReport(
             workbasketIds,
@@ -323,7 +326,7 @@ class WorkbasketReportBuilderImplTest {
   void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult() throws Exception {
     List<String> result =
         cut.createWorkbasketReportBuilder()
-            .workbasketIdIn(Arrays.asList("GibtsSicherNed"))
+            .workbasketIdIn(Collections.singletonList("GibtsSicherNed"))
             .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_14);
     assertThat(result).isNotNull();
   }

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

@@ -99,10 +99,10 @@ class TaskModelsCloneTest {
 
     assertThat(dummyTaskCloned.getAttachments())
         .extracting(AttachmentSummary::getId)
-        .containsOnly((String) null);
+        .containsOnlyNulls();
     assertThat(dummyTaskCloned.getAttachments())
         .extracting(AttachmentSummary::getTaskId)
-        .containsOnly((String) null);
+        .containsOnlyNulls();
   }
 
   @Test

rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/ldap/LdapTest.java

@@ -21,6 +21,7 @@ class LdapTest {
     List<AccessIdRepresentationModel> usersAndGroups = ldapClient.searchUsersAndGroups("lead");
     assertThat(usersAndGroups)
         .extracting(AccessIdRepresentationModel::getAccessId)
-        .containsOnly("teamlead-1", "teamlead-2", "cn=ksc-teamleads,cn=groups,ou=Test,O=TASKANA");
+        .containsExactlyInAnyOrder(
+            "teamlead-1", "teamlead-2", "cn=ksc-teamleads,cn=groups,ou=Test,O=TASKANA");
   }
 }

rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/TaskanaEngineControllerIntTest.java

@@ -45,7 +45,7 @@ class TaskanaEngineControllerIntTest {
             HttpMethod.GET,
             restHelper.defaultRequest(),
             ParameterizedTypeReference.forType(List.class));
-    assertThat(response.getBody()).containsOnly("TASK", "DOCUMENT");
+    assertThat(response.getBody()).containsExactlyInAnyOrder("TASK", "DOCUMENT");
   }
 
   @Test
@@ -56,7 +56,8 @@ class TaskanaEngineControllerIntTest {
             HttpMethod.GET,
             restHelper.defaultRequest(),
             ParameterizedTypeReference.forType(List.class));
-    assertThat(response.getBody()).containsOnly("MANUAL", "EXTERNAL", "AUTOMATIC", "PROCESS");
+    assertThat(response.getBody())
+        .containsExactlyInAnyOrder("MANUAL", "EXTERNAL", "AUTOMATIC", "PROCESS", "EXTERNAL");
   }
 
   @Test

rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskControllerIntTest.java

@@ -527,7 +527,7 @@ class TaskControllerIntTest {
     assertThat(response.getBody()).isNotNull();
     assertThat(response.getBody().getContent())
         .extracting(TaskSummaryRepresentationModel::getTaskId)
-        .containsOnly("TKI:000000000000000000000000000000000013");
+        .containsExactlyInAnyOrder("TKI:000000000000000000000000000000000013");
 
     assertThat(response.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();