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

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

This commit is contained in:
Mustapha Zorgati 2020-07-26 03:38:43 +02:00
parent 38133484c0
commit b3c5084291
28 changed files with 483 additions and 639 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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);
}

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

@ -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

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

@ -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;
}

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

@ -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.lowerAgeLimit} &lt;= (DAYS(DUE) - DAYS(CURRENT_TIMESTAMP)) "
+ "#{selectedItem.upperAgeLimit} >= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) AND "
+ "#{selectedItem.lowerAgeLimit} &lt;= (DAYS(${timestamp}) - DAYS(CURRENT_TIMESTAMP)) "
+ "</if> "
+ "<if test=\"_databaseId == 'h2'\">"
+ "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) AND "
+ "#{selectedItem.lowerAgeLimit} &lt;= DATEDIFF('DAY', CURRENT_TIMESTAMP, DUE) "
+ "#{selectedItem.upperAgeLimit} >= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) AND "
+ "#{selectedItem.lowerAgeLimit} &lt;= DATEDIFF('DAY', CURRENT_TIMESTAMP, ${timestamp}) "
+ "</if> "
+ "<if test=\"_databaseId == 'postgres'\">"
+ "#{selectedItem.upperAgeLimit} >= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) AND "
+ "#{selectedItem.lowerAgeLimit} &lt;= DATE_PART('day', DUE - CURRENT_TIMESTAMP ) "
+ "#{selectedItem.upperAgeLimit} >= DATE_PART('day', ${timestamp} - CURRENT_TIMESTAMP ) AND "
+ "#{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);

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

@ -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

6
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/CustomFieldValueReportBuilderImpl.java → lib/taskana-core/src/main/java/pro/taskana/monitor/internal/reports/TaskCustomFieldValueReportBuilderImpl.java
View File

@ -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) {

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

@ -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)
throws NotAuthorizedException {
TaskCustomField taskCustomField) 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) {
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<SelectedItem> selectedItems) {

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

@ -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();
}

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

@ -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

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

@ -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");

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

@ -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<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(

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

@ -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
.createClassificationCategoryReportBuilder()
.listTaskIdsForSelectedItems(selectedItems);
};
() ->
MONITOR_SERVICE
.createClassificationCategoryReportBuilder()
.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<>();
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<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
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<>();
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<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
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<>();
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<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
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<>();
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<SelectedItem> selectedItems = Arrays.asList(AUTOMATIC, MANUAL);
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<>();
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<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
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<>();
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<SelectedItem> selectedItems = Arrays.asList(EXTERN, AUTOMATIC, MANUAL);
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<>();
SelectedItem s1 = new SelectedItem();
s1.setKey("EXTERN");
s1.setSubKey("INVALID");
s1.setLowerAgeLimit(-5);
s1.setUpperAgeLimit(-2);
selectedItems.add(s1);
final List<SelectedItem> 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);
}

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

@ -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<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<SelectedItem> 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<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();
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<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
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<>();
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<SelectedItem> selectedItems =
Arrays.asList(
new SelectedItem("L10000", "L11000", 0, 0),
new SelectedItem("L10000", "L11000", Integer.MIN_VALUE, -11));
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();
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> domains = new ArrayList<>();
domains.add("DOMAIN_B");
domains.add("DOMAIN_C");
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems = Arrays.asList(L_10000, L_10000_1, L_30000);
List<String> domains = Arrays.asList("DOMAIN_B", "DOMAIN_C");
List<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");

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

@ -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();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
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<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
List<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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();
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<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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();
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<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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();
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<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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();
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<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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();
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<SelectedItem> selectedItems =
Arrays.asList(GESCHAEFTSSTELLE_A, GESCHAEFTSSTELLE_B, GESCHAEFTSSTELLE_C);
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 = new ArrayList<>();
SelectedItem s1 = new SelectedItem();
s1.setKey("Geschaeftsstelle A");
s1.setSubKey("INVALID");
s1.setLowerAgeLimit(-5);
s1.setUpperAgeLimit(-2);
selectedItems.add(s1);
final List<SelectedItem> 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);
}

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

@ -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 = 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<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
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 = 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<SelectedItem> selectedItems = Arrays.asList(S_1, S_2, S_3);
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",

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

@ -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")

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

@ -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")

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

@ -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")

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

@ -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")

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

@ -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

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

@ -184,11 +184,8 @@ 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<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<SelectedItem> selectedItems =
Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
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,

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

@ -354,11 +354,8 @@ 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<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
final List<SelectedItem> selectedItems =
Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
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();
selectedItem.setKey("GIBTSNED");
List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<SelectedItem> selectedItems =
Collections.singletonList(new SelectedItem("GIBTSNED", null, 0, 0));
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,

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

@ -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,

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

@ -200,11 +200,8 @@ 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<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<SelectedItem> selectedItems =
Collections.singletonList(new SelectedItem("EXTERN", null, 1, 5));
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();
}

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

@ -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

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

@ -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");
}
}

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

@ -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

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

@ -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();