diff --git a/history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java b/history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java index 58f188e4c..24239ee2c 100644 --- a/history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java +++ b/history/taskana-simplehistory-provider/src/test/java/acceptance/query/QueryHistoryAccTest.java @@ -50,9 +50,13 @@ class QueryHistoryAccTest extends AbstractAccTest { .orderByCreated(SortDirection.DESCENDING); List 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); } diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/api/SelectedItem.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/api/SelectedItem.java index af4099a1b..e8fdd3c91 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/api/SelectedItem.java +++ b/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 String subKey; - private int upperAgeLimit; - private int lowerAgeLimit; + private final String key; + private final String subKey; + private final 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) { - this.lowerAgeLimit = lowerAgeLimit; + @Override + 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 diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimeIntervalReportBuilder.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimeIntervalReportBuilder.java index 2bc81dba0..4e01d22b4 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/api/reports/TimeIntervalReportBuilder.java +++ b/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 listTaskIdsForSelectedItems(List selectedItems) + List listTaskIdsForSelectedItems( + List selectedItems, TaskTimestamp timestamp) throws NotAuthorizedException, InvalidArgumentException; /** @@ -125,6 +127,14 @@ public interface TimeIntervalReportBuilder< List 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 buildReport(TaskTimestamp timestamp) throws NotAuthorizedException, InvalidArgumentException; } diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java index 78429911c..65a98b079 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java +++ b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapper.java @@ -58,7 +58,7 @@ public interface MonitorMapper { + "" + "" + "" - + "AND T.DUE IS NOT NULL " + + "AND T.${timestamp} IS NOT NULL " + "" + ") AS B " + "GROUP BY B.WORKBASKET_KEY, B.AGE_IN_DAYS" @@ -107,7 +107,7 @@ public interface MonitorMapper { + "" + "AND ((${key} = '${customAttributeFilter.get(key)}')) " + "" - + "AND DUE IS NOT NULL " + + "AND ${timestamp} IS NOT NULL " + "" + ") AS B " + "GROUP BY B.CLASSIFICATION_CATEGORY, B.AGE_IN_DAYS " @@ -156,7 +156,7 @@ public interface MonitorMapper { + "" + "AND ((${key} = '${customAttributeFilter.get(key)}')) " + "" - + "AND DUE IS NOT NULL " + + "AND ${timestamp} IS NOT NULL " + "" + ") AS B " + "GROUP BY B.CLASSIFICATION_KEY, B.AGE_IN_DAYS " @@ -205,7 +205,7 @@ public interface MonitorMapper { + "" + "AND ((${key} = '${customAttributeFilter.get(key)}')) " + "" - + "AND DUE IS NOT NULL " + + "AND T.${timestamp} IS NOT NULL " + "" + ") AS B " + "GROUP BY B.TASK_CLASSIFICATION_KEY, B.ATTACHMENT_CLASSIFICATION_KEY, B.AGE_IN_DAYS " @@ -255,7 +255,7 @@ public interface MonitorMapper { + "" + "AND ((${key} = '${customAttributeFilter.get(key)}')) " + "" - + "AND DUE IS NOT NULL " + + "AND ${timestamp} IS NOT NULL " + "" + ") AS B " + "GROUP BY B.CUSTOM_FIELD, B.AGE_IN_DAYS " @@ -304,23 +304,23 @@ public interface MonitorMapper { + "" + "AND ((${key} = '${customAttributeFilter.get(key)}')) " + "" - + "AND T.DUE IS NOT NULL AND ( " + + "AND T.${timestamp} IS NOT NULL AND ( " + "" + "#{selectedItem.key} = T.${groupedBy} AND " + "" + "A.CLASSIFICATION_KEY = #{selectedItem.subKey} AND " + "" + "" - + "#{selectedItem.upperAgeLimit} >= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) AND " - + "#{selectedItem.lowerAgeLimit} <= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) " + + "#{selectedItem.upperAgeLimit} >= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) AND " + + "#{selectedItem.lowerAgeLimit} <= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) " + " " + "" - + "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) AND " - + "#{selectedItem.lowerAgeLimit} <= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) " + + "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) AND " + + "#{selectedItem.lowerAgeLimit} <= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) " + " " + "" - + "#{selectedItem.upperAgeLimit} >= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) AND " - + "#{selectedItem.lowerAgeLimit} <= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) " + + "#{selectedItem.upperAgeLimit} >= DATE_PART('day', ${timestamp} - CURRENT_TIMESTAMP ) AND " + + "#{selectedItem.lowerAgeLimit} <= DATE_PART('day', ${timestamp} - CURRENT_TIMESTAMP ) " + " " + ") " + "" @@ -335,6 +335,7 @@ public interface MonitorMapper { @Param("excludedClassificationIds") List excludedClassificationIds, @Param("customAttributeFilter") Map customAttributeFilter, @Param("groupedBy") String groupedBy, + @Param("timestamp") TaskTimestamp timestamp, @Param("selectedItems") List selectedItems, @Param("joinWithAttachments") boolean joinWithAttachments); diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorServiceImpl.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorServiceImpl.java index 6fc274ba7..7f372e266 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorServiceImpl.java +++ b/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 diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CustomFieldValueReportBuilderImpl.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TaskCustomFieldValueReportBuilderImpl.java similarity index 94% rename from lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CustomFieldValueReportBuilderImpl.java rename to lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TaskCustomFieldValueReportBuilderImpl.java index c91e7c316..fe897edbc 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CustomFieldValueReportBuilderImpl.java +++ b/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 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) { diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimeIntervalReportBuilderImpl.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimeIntervalReportBuilderImpl.java index cb7c5e398..0b5bff67f 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimeIntervalReportBuilderImpl.java +++ b/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 listTaskIdsForSelectedItems(List selectedItems) + public List listTaskIdsForSelectedItems( + List 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 listCustomAttributeValuesForCustomAttributeName( - TaskCustomField taskCustomField) - throws NotAuthorizedException { + TaskCustomField taskCustomField) throws NotAuthorizedException { LOGGER.debug( "entry to listCustomAttributeValuesForCustomAttributeName(customField = {}), this = {}", taskCustomField, @@ -190,13 +193,15 @@ abstract class TimeIntervalReportBuilderImpl< List selectedItems, List columnHeaders) throws InvalidArgumentException { WorkingDaysToDaysReportConverter instance = WorkingDaysToDaysReportConverter.initialize(columnHeaders, converter); - for (SelectedItem selectedItem : selectedItems) { - selectedItem.setLowerAgeLimit( - Collections.min(instance.convertWorkingDaysToDays(selectedItem.getLowerAgeLimit()))); - selectedItem.setUpperAgeLimit( - Collections.max(instance.convertWorkingDaysToDays(selectedItem.getUpperAgeLimit()))); - } - return selectedItems; + return selectedItems.stream() + .map( + s -> + new SelectedItem( + s.getKey(), + s.getSubKey(), + Collections.min(instance.convertWorkingDaysToDays(s.getLowerAgeLimit())), + Collections.max(instance.convertWorkingDaysToDays(s.getUpperAgeLimit())))) + .collect(Collectors.toList()); } private boolean subKeyIsSet(List selectedItems) { diff --git a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java index fae39d90d..07a5bbf88 100644 --- a/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java +++ b/lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TimestampReportBuilderImpl.java @@ -44,7 +44,8 @@ public class TimestampReportBuilderImpl } @Override - public List listTaskIdsForSelectedItems(List selectedItems) { + public List listTaskIdsForSelectedItems( + List selectedItems, TaskTimestamp timestamp) { throw new UnsupportedOperationException(); } diff --git a/lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java b/lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java index dbb2c8722..75cc9f549 100644 --- a/lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java +++ b/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 diff --git a/lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java b/lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java index e6e315b16..6a67b3c5e 100644 --- a/lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/config/TaskanaRoleConfigAccTest.java @@ -36,7 +36,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl { @Test void testStandardConfig() { Set rolesConfigured = getConfiguration().getRoleMap().keySet(); - assertThat(rolesConfigured).containsOnly(TaskanaRole.values()); + assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values()); Set users = getConfiguration().getRoleMap().get(TaskanaRole.USER); assertThat(users) @@ -73,19 +73,19 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl { getConfiguration().initTaskanaProperties(propertiesFileName, "|"); Set rolesConfigured = getConfiguration().getRoleMap().keySet(); - assertThat(rolesConfigured).containsOnly(TaskanaRole.values()); + assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values()); Set users = getConfiguration().getRoleMap().get(TaskanaRole.USER); - assertThat(users).containsOnly("nobody"); + assertThat(users).containsExactly("nobody"); Set admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN); - assertThat(admins).containsOnly("user", "username"); + assertThat(admins).containsExactlyInAnyOrder("user", "username"); Set businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN); - assertThat(businessAdmins).containsOnly("user2", "user3"); + assertThat(businessAdmins).containsExactlyInAnyOrder("user2", "user3"); Set 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 rolesConfigured = getConfiguration().getRoleMap().keySet(); - assertThat(rolesConfigured).containsOnly(TaskanaRole.values()); + assertThat(rolesConfigured).containsExactlyInAnyOrder(TaskanaRole.values()); Set users = getConfiguration().getRoleMap().get(TaskanaRole.USER); assertThat(users).isEmpty(); Set admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN); - assertThat(admins).containsOnly("user", "name=username,organisation=novatec"); + assertThat(admins).containsExactlyInAnyOrder("user", "name=username,organisation=novatec"); Set businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN); - assertThat(businessAdmins).containsOnly("name=user2, ou = bpm", "user3"); + assertThat(businessAdmins).containsExactlyInAnyOrder("name=user2, ou = bpm", "user3"); Set taskAdmins = getConfiguration().getRoleMap().get(TaskanaRole.TASK_ADMIN); assertThat(taskAdmins).contains("taskadmin"); diff --git a/lib/taskana-core/src/test/java/acceptance/report/GetCustomAttributeValuesForReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/report/GetCustomAttributeValuesForReportAccTest.java index 6c26f03e5..d341ef380 100644 --- a/lib/taskana-core/src/test/java/acceptance/report/GetCustomAttributeValuesForReportAccTest.java +++ b/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 - .createWorkbasketReportBuilder() - .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_2); - }; + () -> + MONITOR_SERVICE + .createWorkbasketReportBuilder() + .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_2); assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class); } @WithAccessId(user = "monitor") @Test void testGetCustomAttributeValuesForOneWorkbasket() throws Exception { - MonitorService monitorService = taskanaEngine.getMonitorService(); - List 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 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 customAttributeFilter = new HashMap<>(); customAttributeFilter.put(TaskCustomField.CUSTOM_2, "Vollkasko"); customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A"); List 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 domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C"); List values = - monitorService + MONITOR_SERVICE .createClassificationCategoryReportBuilder() .domainIn(domains) .excludedClassificationIdIn( diff --git a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationCategoryReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationCategoryReportAccTest.java index 1851b081c..74c807b8e 100644 --- a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationCategoryReportAccTest.java +++ b/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 selectedItems = new ArrayList<>(); ThrowingCallable call = - () -> { - monitorService - .createClassificationCategoryReportBuilder() - .listTaskIdsForSelectedItems(selectedItems); - }; + () -> + MONITOR_SERVICE + .createClassificationCategoryReportBuilder() + .listTaskIdsForSelectedItems(Collections.emptyList(), TaskTimestamp.DUE); assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class); } + @WithAccessId(user = "monitor") + @TestFactory + Stream should_NotThrowError_When_buildReportForTaskState() { + Iterator iterator = Arrays.stream(TaskTimestamp.values()).iterator(); + + ThrowingConsumer 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 columnHeaders = getListOfColumnHeaders(); + + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); + + List 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 columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); List 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 workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); final List columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); List 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 states = Collections.singletonList(TaskState.READY); final List columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); List 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 categories = Arrays.asList("AUTOMATIC", "MANUAL"); final List columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(AUTOMATIC, MANUAL); List 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 domains = Collections.singletonList("DOMAIN_A"); final List columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); List 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 customAttributeFilter = new HashMap<>(); customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A"); final List columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - 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); + final List selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL); List 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 columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - SelectedItem s1 = new SelectedItem(); - s1.setKey("EXTERN"); - s1.setSubKey("INVALID"); - s1.setLowerAgeLimit(-5); - s1.setUpperAgeLimit(-2); - selectedItems.add(s1); + final List selectedItems = + Collections.singletonList(new SelectedItem("EXTERN", "INVALID", -5, -2)); ThrowingCallable call = - () -> { - monitorService - .createClassificationCategoryReportBuilder() - .withColumnHeaders(columnHeaders) - .listTaskIdsForSelectedItems(selectedItems); - }; + () -> + MONITOR_SERVICE + .createClassificationCategoryReportBuilder() + .withColumnHeaders(columnHeaders) + .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE); assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class); } diff --git a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationReportAccTest.java index 196ae0fe5..c6fd81e91 100644 --- a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfClassificationReportAccTest.java +++ b/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(); - - final List 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 selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000); ThrowingCallable call = - () -> { - monitorService - .createClassificationReportBuilder() - .listTaskIdsForSelectedItems(selectedItems); - }; + () -> + MONITOR_SERVICE + .createClassificationReportBuilder() + .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE); assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class); } + @WithAccessId(user = "monitor") + @TestFactory + Stream should_NotThrowError_When_buildReportForTaskState() { + Iterator iterator = Arrays.stream(TaskTimestamp.values()).iterator(); + + ThrowingConsumer 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 columnHeaders = getListOfColumnHeaders(); + List selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000); + + List 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(); - - final List columnHeaders = getListOfColumnHeaders(); - - final List 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 columnHeaders = getListOfColumnHeaders(); + List selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000); List 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 columnHeaders = getListOfColumnHeaders(); - final List selectedItems = new ArrayList<>(); - - SelectedItem s1 = new SelectedItem(); - s1.setKey("L10000"); - 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); + final List selectedItems = + Arrays.asList( + new SelectedItem("L10000", "L11000", 0, 0), + new SelectedItem("L10000", "L11000", Integer.MIN_VALUE, -11)); List 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(); - - final List columnHeaders = getListOfColumnHeaders(); - - final List 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 domains = new ArrayList<>(); - domains.add("DOMAIN_B"); - domains.add("DOMAIN_C"); + List columnHeaders = getListOfColumnHeaders(); + List selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000); + List domains = Arrays.asList("DOMAIN_B", "DOMAIN_C"); List 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"); diff --git a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfTaskCustomFieldValueReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfTaskCustomFieldValueReportAccTest.java index 145bee284..c94768e7d 100644 --- a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfTaskCustomFieldValueReportAccTest.java +++ b/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 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 should_NotThrowError_When_buildReportForTaskState() { + Iterator iterator = Arrays.stream(TaskTimestamp.values()).iterator(); + + ThrowingConsumer 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 columnHeaders = getListOfColumnHeaders(); + List selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); + + List 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(); - - final List columnHeaders = getListOfColumnHeaders(); - - final List 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 columnHeaders = getListOfColumnHeaders(); + List selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 workbasketIds = Collections.singletonList("WBI:000000000000000000000000000000000001"); final List columnHeaders = getListOfColumnHeaders(); - - final List 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 selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 columnHeaders = getListOfColumnHeaders(); - - final List 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 selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 categories = Arrays.asList("AUTOMATIC", "MANUAL"); final List columnHeaders = getListOfColumnHeaders(); - - final List 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 selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 columnHeaders = getListOfColumnHeaders(); - - final List 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 selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 customAttributeFilter = new HashMap<>(); customAttributeFilter.put(TaskCustomField.CUSTOM_1, "Geschaeftsstelle A"); final List columnHeaders = getListOfColumnHeaders(); - - final List 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 selectedItems = + Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C); List 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 columnHeaders = getListOfColumnHeaders(); - - final List selectedItems = new ArrayList<>(); - - SelectedItem s1 = new SelectedItem(); - s1.setKey("Geschaeftsstelle A"); - s1.setSubKey("INVALID"); - s1.setLowerAgeLimit(-5); - s1.setUpperAgeLimit(-2); - selectedItems.add(s1); + final List selectedItems = + Collections.singletonList(new SelectedItem("Geschaeftsstelle A", "INVALID", -5, -2)); ThrowingCallable call = () -> - monitorService + MONITOR_SERVICE .createClassificationCategoryReportBuilder() .withColumnHeaders(columnHeaders) - .listTaskIdsForSelectedItems(selectedItems); + .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE); assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class); } diff --git a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfWorkbasketReportAccTest.java b/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfWorkbasketReportAccTest.java index f33d0e709..b03e38a56 100644 --- a/lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfWorkbasketReportAccTest.java +++ b/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 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 should_NotThrowError_When_buildReportForTaskState() { + Iterator iterator = Arrays.stream(TaskTimestamp.values()).iterator(); + + ThrowingConsumer 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 columnHeaders = getListOfColumnHeaders(); + final List selectedItems = Arrays.asList(S_1, S_2, S_3); + + List 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 columnHeaders = getListOfColumnHeaders(); - - final List 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); + final List selectedItems = Arrays.asList(S_1, S_2, S_3); List 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 columnHeaders = getListOfColumnHeaders(); - - final List 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); + final List selectedItems = Arrays.asList(S_1, S_2, S_3); List 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", diff --git a/lib/taskana-core/src/test/java/acceptance/task/CallbackStateAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/CallbackStateAccTest.java index 8617ca07f..20c446606 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/CallbackStateAccTest.java +++ b/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 failedTaskIds = bulkResult.getFailedIds(); - assertThat(failedTaskIds).containsOnly(createdTask3.getExternalId()); + assertThat(failedTaskIds).containsExactlyInAnyOrder(createdTask3.getExternalId()); } @WithAccessId(user = "admin") diff --git a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java index a44af8e20..b8ee8ef4d 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java +++ b/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") diff --git a/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java index 518fa25ce..29800ad79 100644 --- a/lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAttachmentsAccTest.java +++ b/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") diff --git a/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccessItemsAccTest.java b/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccessItemsAccTest.java index f77f859ac..a70694485 100644 --- a/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccessItemsAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketAccessItemsAccTest.java @@ -170,7 +170,9 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest { }; List results = workbasketService.createWorkbasketAccessItemQuery().idIn(expectedIds).list(); - assertThat(results).extracting(WorkbasketAccessItem::getId).containsOnly(expectedIds); + assertThat(results) + .extracting(WorkbasketAccessItem::getId) + .containsExactlyInAnyOrder(expectedIds); } @WithAccessId(user = "businessadmin") diff --git a/lib/taskana-core/src/test/java/pro/taskana/common/internal/security/JaasExtensionTest.java b/lib/taskana-core/src/test/java/pro/taskana/common/internal/security/JaasExtensionTest.java index 1e1d41f68..adb1dbae9 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/common/internal/security/JaasExtensionTest.java +++ b/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 diff --git a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java index e2a0ccb18..01482ba04 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationClassificationCategoryReportBuilderImplTest.java @@ -184,11 +184,8 @@ class ClassificationClassificationCategoryReportBuilderImplTest { final List columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - List selectedItems = Collections.singletonList(selectedItem); + List selectedItems = + Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5)); List 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 selectedItems = Collections.singletonList(selectedItem); List 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 columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - List expectedResult = Collections.singletonList("Geschaeftsstelle A"); when(monitorMapperMock.getCustomAttributeValuesForReport( workbasketIds, diff --git a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java index 1b02d2634..f31d123f7 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/ClassificationReportBuilderImplTest.java @@ -354,11 +354,8 @@ class ClassificationReportBuilderImplTest { final List columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - final List selectedItems = Collections.singletonList(selectedItem); + final List selectedItems = + Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5)); final List 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(); - selectedItem.setKey("GIBTSNED"); - List selectedItems = Collections.singletonList(selectedItem); + List selectedItems = + Collections.singletonList(new SelectedItem("GIBTSNED", null, 0, 0)); List result = cut.createClassificationReportBuilder() .workbasketIdIn(Collections.singletonList("DieGibtsEhNed")) - .listTaskIdsForSelectedItems(selectedItems); + .listTaskIdsForSelectedItems(selectedItems, TaskTimestamp.DUE); assertThat(result).isNotNull(); } @@ -429,11 +435,6 @@ class ClassificationReportBuilderImplTest { final List columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - final List expectedResult = Collections.singletonList("Geschaeftsstelle A"); when(monitorMapperMock.getCustomAttributeValuesForReport( workbasketIds, diff --git a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/TaskCustomFieldValueReportBuilderImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/TaskCustomFieldValueReportBuilderImplTest.java index 722378e87..7899525a3 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/TaskCustomFieldValueReportBuilderImplTest.java +++ b/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 columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - List expectedResult = Collections.singletonList("Geschaeftsstelle A"); when(monitorMapperMock.getCustomAttributeValuesForReport( workbasketIds, diff --git a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java index b4dbd8d6d..d364ec7d1 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java +++ b/lib/taskana-core/src/test/java/pro/taskana/monitor/internal/WorkbasketReportBuilderImplTest.java @@ -200,11 +200,8 @@ class WorkbasketReportBuilderImplTest { final List columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - List selectedItems = Collections.singletonList(selectedItem); + List selectedItems = + Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5)); List 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 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 columnHeaders = Collections.singletonList(new TimeIntervalColumnHeader(0, 0)); - SelectedItem selectedItem = new SelectedItem(); - selectedItem.setKey("EXTERN"); - selectedItem.setLowerAgeLimit(1); - selectedItem.setUpperAgeLimit(5); - List expectedResult = Collections.singletonList("Geschaeftsstelle A"); when(monitorMapperMock.getCustomAttributeValuesForReport( workbasketIds, @@ -323,7 +326,7 @@ class WorkbasketReportBuilderImplTest { void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult() throws Exception { List result = cut.createWorkbasketReportBuilder() - .workbasketIdIn(Arrays.asList("GibtsSicherNed")) + .workbasketIdIn(Collections.singletonList("GibtsSicherNed")) .listCustomAttributeValuesForCustomAttributeName(TaskCustomField.CUSTOM_14); assertThat(result).isNotNull(); } diff --git a/lib/taskana-core/src/test/java/pro/taskana/task/internal/models/TaskModelsCloneTest.java b/lib/taskana-core/src/test/java/pro/taskana/task/internal/models/TaskModelsCloneTest.java index df22ef33b..0d4239052 100644 --- a/lib/taskana-core/src/test/java/pro/taskana/task/internal/models/TaskModelsCloneTest.java +++ b/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 diff --git a/rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/ldap/LdapTest.java b/rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/ldap/LdapTest.java index 7542fb1ff..14c43890c 100644 --- a/rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/ldap/LdapTest.java +++ b/rest/taskana-rest-spring-example-common/src/test/java/pro/taskana/ldap/LdapTest.java @@ -21,6 +21,7 @@ class LdapTest { List 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"); } } diff --git a/rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/TaskanaEngineControllerIntTest.java b/rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/TaskanaEngineControllerIntTest.java index 941204259..6654fe6f7 100644 --- a/rest/taskana-rest-spring/src/test/java/pro/taskana/common/rest/TaskanaEngineControllerIntTest.java +++ b/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 diff --git a/rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskControllerIntTest.java b/rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskControllerIntTest.java index 0023e07c0..e6e6c6751 100644 --- a/rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskControllerIntTest.java +++ b/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();