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

TSK-1180: migrate from JUnit 5 assertions to assertJ assertions 

TSK-1180: remove hemcrest dependency

TSK-1180: convertes junit Assertions.ThrownBy to assertJ style

TSK-1180: add archUnit rule for checking if org.junit.jupiter.api.Assertions is used in classes

TSK-1080: fixed archunit tests which failed due to rebase

test

fixed order problem with H2 database -> set collation to DEFAULT_de_DE

disabled test with collation problems, readded old style assrtj test
This commit is contained in:
Sascha Frevel 2020-04-08 08:53:46 +02:00 committed by Mustapha Zorgati
parent 4451fcb9c2
commit 2c5634c917
106 changed files with 3829 additions and 4430 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/taskana-core/pom.xml
View File

@ -48,12 +48,6 @@
<version>${version.assertj}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
<version>${version.hamcrest}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>

10
lib/taskana-core/src/main/java/pro/taskana/TaskanaEngineConfiguration.java
View File

@ -49,7 +49,9 @@ public class TaskanaEngineConfiguration {
private static final String USER_NAME = "sa";
private static final String USER_PASSWORD = "sa";
private static final String JDBC_H2_MEM_TASKANA =
"jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0";
"jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0;"
+ "INIT=CREATE SCHEMA IF NOT EXISTS TASKANA\\;"
+ "SET COLLATION DEFAULT_de_DE ";
private static final String H2_DRIVER = "org.h2.Driver";
private static final String TASKANA_PROPERTIES = "/taskana.properties";
private static final String TASKANA_ROLES_SEPARATOR = "|";
@ -172,7 +174,7 @@ public class TaskanaEngineConfiguration {
private void initGermanHolidaysEnabled(Properties props) {
String enabled = props.getProperty(TASKANA_GERMAN_HOLIDAYS_ENABLED);
if (enabled != null && ! enabled.isEmpty()) {
if (enabled != null && !enabled.isEmpty()) {
germanPublicHolidaysEnabled = Boolean.parseBoolean(enabled);
} else {
germanPublicHolidaysEnabled = false;
@ -183,7 +185,9 @@ public class TaskanaEngineConfiguration {
public static DataSource createDefaultDataSource() {
LOGGER.info(
"No datasource is provided. A inmemory db is used: "
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0', 'sa', 'sa'");
+ "'org.h2.Driver', 'jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0;"
+ "INIT=CREATE SCHEMA IF NOT EXISTS TASKANA\\;"
+ "SET COLLATION DEFAULT_de_DE', 'sa', 'sa'");
return createDatasource(H2_DRIVER, JDBC_H2_MEM_TASKANA, USER_NAME, USER_PASSWORD);
}

10
lib/taskana-core/src/main/java/pro/taskana/classification/internal/models/ClassificationSummaryImpl.java
View File

@ -292,16 +292,14 @@ public class ClassificationSummaryImpl implements ClassificationSummary {
public String toString() {
return "ClassificationSummaryImpl [id="
+ id
+ "applicationEntryPoint="
+ ", applicationEntryPoint="
+ applicationEntryPoint
+ ", key="
+ key
+ ", category="
+ category
+ ", type="
+ type
+ ", domain="
+ domain
+ ", key="
+ key
+ ", name="
+ name
+ ", parentId="
@ -312,6 +310,8 @@ public class ClassificationSummaryImpl implements ClassificationSummary {
+ priority
+ ", serviceLevel="
+ serviceLevel
+ ", type="
+ type
+ ", custom1="
+ custom1
+ ", custom2="

20
lib/taskana-core/src/main/java/pro/taskana/common/internal/util/CheckedFunction.java Normal file
View File

@ -0,0 +1,20 @@
package pro.taskana.common.internal.util;
import java.util.function.Function;
import pro.taskana.common.api.exceptions.SystemException;
@FunctionalInterface
public interface CheckedFunction<T, E> {
static <T, E> Function<T, E> wrap(CheckedFunction<T, E> checkedFunction) {
return t -> {
try {
return checkedFunction.accept(t);
} catch (Exception e) {
throw new SystemException("Caught exception", e);
}
};
}
E accept(T t) throws Exception;
}

26
lib/taskana-core/src/main/java/pro/taskana/common/internal/util/Triplet.java Normal file
View File

@ -0,0 +1,26 @@
package pro.taskana.common.internal.util;
public class Triplet<L, M, R> {
private final L left;
private final M middle;
private final R right;
public Triplet(L left, M middle, R right) {
this.left = left;
this.middle = middle;
this.right = right;
}
public L getLeft() {
return left;
}
public M getMiddle() {
return middle;
}
public R getRight() {
return right;
}
}

2
lib/taskana-core/src/main/java/pro/taskana/task/api/models/ObjectReference.java
View File

@ -101,7 +101,7 @@ public class ObjectReference {
this.value = value;
}
protected ObjectReference copy() {
public ObjectReference copy() {
return new ObjectReference(this);
}

5
lib/taskana-core/src/main/resources/sql/taskana-schema.sql
View File

@ -2,6 +2,11 @@ CREATE SCHEMA IF NOT EXISTS %schemaName%;
SET SCHEMA %schemaName%;
-- MOved to h2 jdbc connect string, because of taskana-spring-example project is using two schemas.
-- There the order of the schema setup's (dbcustom, taskana) should be switched then we can set collation
-- here in this file!
-- SET COLLATION DEFAULT_de_DE;
CREATE TABLE TASKANA_SCHEMA_VERSION(
ID INT NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1 INCREMENT BY 1),
VERSION VARCHAR(255) NOT NULL,

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

@ -2,8 +2,6 @@ package acceptance.classification;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Test;
@ -265,7 +263,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
newClassification = classificationService.createClassification(newClassification);
assertNotNull(newClassification.getId());
assertNotEquals(newClassification.getId(), oldClassification.getId());
assertThat(newClassification.getId()).isNotNull();
assertThat(newClassification.getId()).isNotEqualTo(oldClassification.getId());
}
}

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

@ -1,11 +1,10 @@
package acceptance.classification;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -37,8 +36,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
classificationService.deleteClassification("L140101", "DOMAIN_A");
Classification classification = classificationService.getClassification("L140101", "DOMAIN_A");
assertNotNull(classification);
assertEquals("", classification.getDomain());
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
}
@WithAccessId(
@ -46,9 +45,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"group_1", "group_2"})
@Test
void testDeleteClassificationInDomainUserIsNotAuthorized() {
Assertions.assertThrows(
NotAuthorizedException.class,
() -> classificationService.deleteClassification("L140101", "DOMAIN_A"));
ThrowingCallable call = () -> classificationService.deleteClassification("L140101", "DOMAIN_A");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -56,9 +54,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"group_1", "businessadmin"})
@Test
void testThrowExeptionIfDeleteClassificationWithExistingTasks() {
Assertions.assertThrows(
ClassificationInUseException.class,
() -> classificationService.deleteClassification("L1050", "DOMAIN_A"));
ThrowingCallable call = () -> classificationService.deleteClassification("L1050", "DOMAIN_A");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);
}
@WithAccessId(
@ -66,9 +63,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"group_1", "businessadmin"})
@Test
void testThrowExeptionIfDeleteMasterClassificationWithExistingTasks() {
Assertions.assertThrows(
ClassificationInUseException.class,
() -> classificationService.deleteClassification("L1050", ""));
ThrowingCallable call = () -> classificationService.deleteClassification("L1050", "");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);
}
@WithAccessId(
@ -79,9 +75,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException {
classificationService.deleteClassification("L3060", "");
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.getClassification("L3060", "DOMAIN_A"));
ThrowingCallable call = () -> classificationService.getClassification("L3060", "DOMAIN_A");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@WithAccessId(
@ -89,9 +84,8 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testDeleteMasterClassificationWithExistingAttachment() {
Assertions.assertThrows(
ClassificationInUseException.class,
() -> classificationService.deleteClassification("L12010", ""));
ThrowingCallable call = () -> classificationService.deleteClassification("L12010", "");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);
}
@WithAccessId(
@ -101,21 +95,19 @@ class DeleteClassificationAccTest extends AbstractAccTest {
void testThrowExceptionWhenChildClassificationIsInUseAndRollback()
throws ClassificationNotFoundException {
Assertions.assertThrows(
ClassificationInUseException.class,
() -> classificationService.deleteClassification("L11010", "DOMAIN_A"));
ThrowingCallable call = () -> classificationService.deleteClassification("L11010", "DOMAIN_A");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);
Classification rollback = classificationService.getClassification("L11010", "DOMAIN_A");
assertEquals("DOMAIN_A", rollback.getDomain());
assertThat(rollback.getDomain()).isEqualTo("DOMAIN_A");
Assertions.assertThrows(
ClassificationInUseException.class,
() -> classificationService.deleteClassification("L11010", ""));
call = () -> classificationService.deleteClassification("L11010", "");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);
Classification rollbackMaster = classificationService.getClassification("L11010", "");
Classification rollbackA = classificationService.getClassification("L11010", "DOMAIN_A");
assertEquals(rollbackMaster.getKey(), rollbackA.getKey());
assertNotEquals(rollbackMaster.getDomain(), rollbackA.getDomain());
assertThat(rollbackA.getKey()).isEqualTo(rollbackMaster.getKey());
assertThat(rollbackA.getDomain()).isNotEqualTo(rollbackMaster.getDomain());
}
@WithAccessId(
@ -123,9 +115,9 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testThrowClassificationNotFoundIfClassificationNotExists() {
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.deleteClassification("not existing classification key", ""));
ThrowingCallable call =
() -> classificationService.deleteClassification("not existing classification key", "");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@WithAccessId(
@ -133,8 +125,7 @@ class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testThrowClassificationNotFoundIfClassificationNotExistsInDomain() {
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.deleteClassification("L10000", "DOMAIN_B"));
ThrowingCallable call = () -> classificationService.deleteClassification("L10000", "DOMAIN_B");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
}

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

@ -1,11 +1,11 @@
package acceptance.classification;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import pro.taskana.classification.api.ClassificationService;
@ -27,62 +27,62 @@ class GetClassificationAccTest extends AbstractAccTest {
void testFindAllClassifications() {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().list();
assertNotNull(classificationSummaryList);
assertThat(classificationSummaryList).isNotNull();
}
@Test
void testGetOneClassificationByKeyAndDomain() throws ClassificationNotFoundException {
Classification classification = classificationService.getClassification("T6310", "DOMAIN_A");
assertNotNull(classification);
assertEquals("CLI:100000000000000000000000000000000011", classification.getId());
assertEquals("", classification.getParentId());
assertEquals("AUTOMATIC", classification.getCategory());
assertEquals("TASK", classification.getType());
assertEquals(true, classification.getIsValidInDomain());
assertEquals("T-GUK Honorarrechnung erstellen", classification.getName());
assertEquals(2, classification.getPriority());
assertEquals("P2D", classification.getServiceLevel());
assertEquals("point0815", classification.getApplicationEntryPoint());
assertEquals("VNR", classification.getCustom1());
assertEquals("custom2", classification.getCustom2());
assertEquals("custom3", classification.getCustom3());
assertEquals("custom4", classification.getCustom4());
assertEquals("custom5", classification.getCustom5());
assertEquals("custom6", classification.getCustom6());
assertEquals("custom7", classification.getCustom7());
assertEquals("custom8", classification.getCustom8());
assertThat(classification).isNotNull();
assertThat(classification.getId()).isEqualTo("CLI:100000000000000000000000000000000011");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getIsValidInDomain()).isEqualTo(true);
assertThat(classification.getName()).isEqualTo("T-GUK Honorarrechnung erstellen");
assertThat(classification.getPriority()).isEqualTo(2);
assertThat(classification.getServiceLevel()).isEqualTo("P2D");
assertThat(classification.getApplicationEntryPoint()).isEqualTo("point0815");
assertThat(classification.getCustom1()).isEqualTo("VNR");
assertThat(classification.getCustom2()).isEqualTo("custom2");
assertThat(classification.getCustom3()).isEqualTo("custom3");
assertThat(classification.getCustom4()).isEqualTo("custom4");
assertThat(classification.getCustom5()).isEqualTo("custom5");
assertThat(classification.getCustom6()).isEqualTo("custom6");
assertThat(classification.getCustom7()).isEqualTo("custom7");
assertThat(classification.getCustom8()).isEqualTo("custom8");
}
@Test
void testGetOneClassificationById() throws ClassificationNotFoundException {
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000011");
assertNotNull(classification);
assertEquals("T6310", classification.getKey());
assertEquals("", classification.getParentId());
assertEquals("AUTOMATIC", classification.getCategory());
assertEquals("TASK", classification.getType());
assertEquals("DOMAIN_A", classification.getDomain());
assertEquals(true, classification.getIsValidInDomain());
assertEquals("T-GUK Honorarrechnung erstellen", classification.getName());
assertEquals(2, classification.getPriority());
assertEquals("P2D", classification.getServiceLevel());
assertEquals("point0815", classification.getApplicationEntryPoint());
assertEquals("VNR", classification.getCustom1());
assertEquals("custom2", classification.getCustom2());
assertEquals("custom3", classification.getCustom3());
assertEquals("custom4", classification.getCustom4());
assertEquals("custom5", classification.getCustom5());
assertEquals("custom6", classification.getCustom6());
assertEquals("custom7", classification.getCustom7());
assertEquals("custom8", classification.getCustom8());
assertThat(classification).isNotNull();
assertThat(classification.getKey()).isEqualTo("T6310");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getDomain()).isEqualTo("DOMAIN_A");
assertThat(classification.getIsValidInDomain()).isEqualTo(true);
assertThat(classification.getName()).isEqualTo("T-GUK Honorarrechnung erstellen");
assertThat(classification.getPriority()).isEqualTo(2);
assertThat(classification.getServiceLevel()).isEqualTo("P2D");
assertThat(classification.getApplicationEntryPoint()).isEqualTo("point0815");
assertThat(classification.getCustom1()).isEqualTo("VNR");
assertThat(classification.getCustom2()).isEqualTo("custom2");
assertThat(classification.getCustom3()).isEqualTo("custom3");
assertThat(classification.getCustom4()).isEqualTo("custom4");
assertThat(classification.getCustom5()).isEqualTo("custom5");
assertThat(classification.getCustom6()).isEqualTo("custom6");
assertThat(classification.getCustom7()).isEqualTo("custom7");
assertThat(classification.getCustom8()).isEqualTo("custom8");
}
@Test
void testGetClassificationWithSpecialCharacter() throws ClassificationNotFoundException {
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000009");
assertEquals("Zustimmungserklärung", classification.getName());
assertThat(classification.getName()).isEqualTo("Zustimmungserklärung");
}
@Test
@ -91,55 +91,53 @@ class GetClassificationAccTest extends AbstractAccTest {
classificationService
.getClassification("CLI:100000000000000000000000000000000011")
.asSummary();
assertNotNull(classification);
assertEquals("T6310", classification.getKey());
assertEquals("", classification.getParentId());
assertEquals("AUTOMATIC", classification.getCategory());
assertEquals("TASK", classification.getType());
assertEquals("DOMAIN_A", classification.getDomain());
assertEquals("T-GUK Honorarrechnung erstellen", classification.getName());
// assertEquals("Generali Unterstützungskasse Honorar wird fällig",
// classification.getDescription());
assertEquals(2, classification.getPriority());
assertEquals("P2D", classification.getServiceLevel());
assertThat(classification).isNotNull();
assertThat(classification.getKey()).isEqualTo("T6310");
assertThat(classification.getParentId()).isEqualTo("");
assertThat(classification.getCategory()).isEqualTo("AUTOMATIC");
assertThat(classification.getType()).isEqualTo("TASK");
assertThat(classification.getDomain()).isEqualTo("DOMAIN_A");
assertThat(classification.getName()).isEqualTo("T-GUK Honorarrechnung erstellen");
// assertThat(classification.getDescription())
// .isEqualTo("Generali Unterstützungskasse Honorar wird fällig");
assertThat(classification.getPriority()).isEqualTo(2);
assertThat(classification.getServiceLevel()).isEqualTo("P2D");
}
@Test
void testGetOneClassificationByIdFails() {
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.getClassification("CLI:100000000470000000000000000000000011"));
ThrowingCallable call =
() -> classificationService.getClassification("CLI:100000000470000000000000000000000011");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@Test
void testGetClassificationByNullKeyFails() {
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.getClassification(null, ""));
ThrowingCallable call = () -> classificationService.getClassification(null, "");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@Test
void testGetClassificationByInvalidKeyAndDomain() {
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.getClassification("Key0815", "NOT_EXISTING"));
ThrowingCallable call =
() -> classificationService.getClassification("Key0815", "NOT_EXISTING");
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@Test
void testGetOneClassificationForDomainAndGetClassificationFromMasterDomain()
throws ClassificationNotFoundException {
Classification classification = classificationService.getClassification("L10000", "DOMAIN_B");
assertNotNull(classification);
assertEquals("", classification.getDomain());
assertEquals(999L, classification.getPriority());
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
assertThat(classification.getPriority()).isEqualTo(999L);
}
@Test
void testGetOneClassificationForMasterDomain() throws ClassificationNotFoundException {
Classification classification = classificationService.getClassification("L10000", "");
assertNotNull(classification);
assertEquals("", classification.getDomain());
assertEquals(999L, classification.getPriority());
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
assertThat(classification.getPriority()).isEqualTo(999L);
}
}

392
lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java
View File

@ -1,23 +1,29 @@
package acceptance.classification;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static java.lang.String.CASE_INSENSITIVE_ORDER;
import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.classification.api.ClassificationQueryColumnName.CREATED;
import static pro.taskana.classification.api.ClassificationQueryColumnName.NAME;
import static pro.taskana.classification.api.ClassificationQueryColumnName.TYPE;
import static pro.taskana.classification.api.ClassificationQueryColumnName.VALID_IN_DOMAIN;
import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
import acceptance.AbstractAccTest;
import java.text.Collator;
import java.time.Instant;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Locale;
import org.assertj.core.api.Condition;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
@ -29,33 +35,29 @@ import pro.taskana.security.WithAccessId;
@ExtendWith(JaasExtension.class)
class QueryClassificationAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
private static ClassificationService classificationService;
QueryClassificationAccTest() {
super();
@BeforeAll
static void setup() {
classificationService = taskanaEngine.getClassificationService();
}
@Test
void testQueryClassificationValuesForColumnName() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<String> columnValueList =
classificationService.createClassificationQuery().listValues(NAME, null);
assertNotNull(columnValueList);
assertEquals(16, columnValueList.size());
assertThat(columnValueList).hasSize(16);
columnValueList = classificationService.createClassificationQuery().listValues(TYPE, null);
assertNotNull(columnValueList);
assertEquals(2, columnValueList.size());
assertThat(columnValueList).hasSize(2);
columnValueList =
classificationService.createClassificationQuery().domainIn("").listValues(TYPE, null);
assertNotNull(columnValueList);
assertEquals(2, columnValueList.size());
assertThat(columnValueList).hasSize(2);
columnValueList =
classificationService.createClassificationQuery().domainIn("").listValues(CREATED, null);
assertNotNull(columnValueList);
assertThat(columnValueList);
columnValueList =
classificationService
@ -63,13 +65,11 @@ class QueryClassificationAccTest extends AbstractAccTest {
.domainIn("")
.validInDomainEquals(false)
.listValues(VALID_IN_DOMAIN, null);
assertNotNull(columnValueList);
assertEquals(1, columnValueList.size()); // all are false in ""
assertThat(columnValueList).hasSize(1); // all are false in ""
}
@Test
void testFindClassificationsByCategoryAndDomain() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classificationSummaryList =
classificationService
.createClassificationQuery()
@ -77,13 +77,11 @@ class QueryClassificationAccTest extends AbstractAccTest {
.domainIn("DOMAIN_A")
.list();
assertNotNull(classificationSummaryList);
assertEquals(2, classificationSummaryList.size());
assertThat(classificationSummaryList).hasSize(2);
}
@Test
void testGetOneClassificationForMultipleDomains() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -91,13 +89,11 @@ class QueryClassificationAccTest extends AbstractAccTest {
.domainIn("DOMAIN_A", "DOMAIN_B", "")
.list();
assertNotNull(classifications);
assertEquals(2, classifications.size());
assertThat(classifications).hasSize(2);
}
@Test
void testGetClassificationsForTypeAndParent() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -105,25 +101,16 @@ class QueryClassificationAccTest extends AbstractAccTest {
.parentIdIn("")
.list();
assertNotNull(classifications);
assertEquals(28, classifications.size());
List<ClassificationSummary> documentTypes =
classifications.stream()
.filter(c -> c.getType().equals("DOCUMENT"))
.collect(Collectors.toList());
assertEquals(2, documentTypes.size());
List<ClassificationSummary> taskTypes =
classifications.stream()
.filter(c -> c.getType().equals("TASK"))
.collect(Collectors.toList());
assertEquals(26, taskTypes.size());
assertThat(classifications)
.hasSize(28)
.extracting(ClassificationSummary::getType)
.containsOnly("TASK", "DOCUMENT")
.areExactly(26, new Condition<>("TASK"::equals, "TASK"))
.areExactly(2, new Condition<>("DOCUMENT"::equals, "DOCUMENT"));
}
@Test
void testGetClassificationsForKeyAndCategories() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -131,25 +118,16 @@ class QueryClassificationAccTest extends AbstractAccTest {
.categoryIn("EXTERNAL", "MANUAL")
.list();
assertNotNull(classifications);
assertEquals(5, classifications.size());
List<ClassificationSummary> externCategory =
classifications.stream()
.filter(c -> c.getCategory().equals("EXTERNAL"))
.collect(Collectors.toList());
assertEquals(2, externCategory.size());
List<ClassificationSummary> manualCategory =
classifications.stream()
.filter(c -> c.getCategory().equals("MANUAL"))
.collect(Collectors.toList());
assertEquals(3, manualCategory.size());
assertThat(classifications)
.hasSize(5)
.extracting(ClassificationSummary::getCategory)
.containsOnly("EXTERNAL", "MANUAL")
.areExactly(2, new Condition<>("EXTERNAL"::equals, "EXTERNAL"))
.areExactly(3, new Condition<>("MANUAL"::equals, "MANUAL"));
}
@Test
void testGetClassificationsWithParentId() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -158,8 +136,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
.parentIdIn("CLI:100000000000000000000000000000000014")
.list();
assertNotNull(classifications);
assertEquals(1, classifications.size());
assertThat(classifications).hasSize(1);
classifications =
classificationService
@ -172,13 +149,11 @@ class QueryClassificationAccTest extends AbstractAccTest {
"CLI:100000000000000000000000000000000011")
.domainIn("DOMAIN_A")
.list();
assertNotNull(classifications);
assertEquals(2, classifications.size());
assertThat(classifications).hasSize(2);
}
@Test
void testGetClassificationsWithParentKey() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -186,9 +161,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
.categoryIn("EXTERNAL", "MANUAL")
.parentKeyIn("L10000")
.list();
assertNotNull(classifications);
assertEquals(2, classifications.size());
assertThat(classifications).hasSize(2);
classifications =
classificationService
@ -198,26 +171,22 @@ class QueryClassificationAccTest extends AbstractAccTest {
.parentKeyIn("L10000", "T2100", "T6310")
.domainIn("DOMAIN_A")
.list();
assertNotNull(classifications);
assertEquals(2, classifications.size());
assertThat(classifications).hasSize(2);
}
@Test
void testGetClassificationsWithCustom1() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
.customAttributeIn("1", "VNR,RVNR,KOLVNR", "VNR")
.domainIn("DOMAIN_A")
.list();
assertNotNull(classifications);
assertEquals(14, classifications.size());
assertThat(classifications).hasSize(14);
}
@Test
void testGetClassificationsWithCustom1Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -225,27 +194,23 @@ class QueryClassificationAccTest extends AbstractAccTest {
.domainIn("DOMAIN_A")
.typeIn("TASK")
.list();
assertNotNull(classifications);
assertEquals(13, classifications.size());
assertThat(classifications).hasSize(13);
}
@Test
void testGetClassificationsWithParentAndCustom2() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
.parentIdIn("CLI:100000000000000000000000000000000004")
.customAttributeIn("2", "TEXT_1", "TEXT_2")
.list();
// zwei tests
assertNotNull(classifications);
assertEquals(3, classifications.size());
assertThat(classifications).hasSize(3);
}
@Test
void testFindClassificationsByCreatedTimestamp() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> classificationSummaryList =
classificationService
.createClassificationQuery()
@ -253,20 +218,19 @@ class QueryClassificationAccTest extends AbstractAccTest {
.createdWithin(todaysInterval())
.list();
assertNotNull(classificationSummaryList);
assertEquals(17, classificationSummaryList.size());
assertThat(classificationSummaryList).hasSize(17);
}
@Test
void testFindClassificationsByPriorityAndValidInDomain() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> list =
classificationService
.createClassificationQuery()
.validInDomainEquals(Boolean.TRUE)
.priorityIn(1, 2, 3)
.list();
assertEquals(15, list.size());
assertThat(list).hasSize(15);
}
@WithAccessId(userName = "businessadmin")
@ -274,9 +238,9 @@ class QueryClassificationAccTest extends AbstractAccTest {
void testFindClassificationByModifiedWithin()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
String clId = "CLI:200000000000000000000000000000000015";
classificationService.updateClassification(classificationService.getClassification(clId));
List<ClassificationSummary> list =
classificationService
.createClassificationQuery()
@ -284,403 +248,419 @@ class QueryClassificationAccTest extends AbstractAccTest {
new TimeInterval(
classificationService.getClassification(clId).getModified(), Instant.now()))
.list();
assertEquals(1, list.size());
assertEquals(clId, list.get(0).getId());
assertThat(list).hasSize(1).first().extracting(ClassificationSummary::getId).isEqualTo(clId);
}
@Test
void testQueryForNameLike() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().nameLike("Dynamik%").list();
assertEquals(8, results.size());
assertThat(results).hasSize(8);
}
@Test
void testQueryForNameIn() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.nameIn("Widerruf", "OLD-Leistungsfall")
.list();
assertEquals(6, results.size());
assertThat(results).hasSize(6);
}
@Test
void testQueryForDescriptionLike() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().descriptionLike("Widerruf%").list();
assertEquals(9, results.size());
assertThat(results).hasSize(9);
}
@Test
void testQueryForServiceLevelIn() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().serviceLevelIn("P2D").list();
assertEquals(5, results.size());
assertThat(results).hasSize(5);
}
@Test
void testQueryForServiceLevelLike() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().serviceLevelLike("PT%").list();
assertEquals(0, results.size());
assertThat(results).isEmpty();
}
@Test
void testQueryForApplicationEntryPointIn() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.applicationEntryPointIn("specialPoint", "point0815")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForApplicationEntryPointLike() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.applicationEntryPointLike("point%")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom1In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.customAttributeIn("1", "VNR,RVNR,KOLVNR, ANR", "VNR")
.list();
assertEquals(17, results.size());
assertThat(results).hasSize(17);
}
@Test
void testQueryForCustom2In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.customAttributeIn("2", "CUSTOM2", "custom2")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom3In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.customAttributeIn("3", "Custom3", "custom3")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom4In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("4", "custom4").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom5In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("5", "custom5").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom6In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("6", "custom6").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom7In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.customAttributeIn("7", "custom7", "custom_7")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom8In() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.customAttributeIn("8", "custom_8", "custom8")
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@Test
void testQueryForCustom2Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("2", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom3Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("3", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom4Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("4", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom5Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("5", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom6Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("6", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom7Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("7", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForCustom8Like() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("8", "cus%").list();
assertEquals(4, results.size());
assertThat(results).hasSize(4);
}
@Test
void testQueryForOrderByKeyAsc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByKey(asc).list();
assertEquals("A12", results.get(0).getKey());
classificationService.createClassificationQuery().orderByKey(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getKey)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByParentIdDesc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByDomain(asc)
.orderByParentId(desc)
.list();
assertEquals("CLI:000000000000000000000000000000000020", results.get(0).getParentId());
classificationService.createClassificationQuery().orderByParentId(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getParentId)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByParentKeyDesc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByParentKey(desc).list();
assertEquals("T6310", results.get(0).getParentKey());
classificationService.createClassificationQuery().orderByParentKey(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getParentKey)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByCategoryDesc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByCategory(desc).list();
assertEquals("MANUAL", results.get(0).getCategory());
classificationService.createClassificationQuery().orderByCategory(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCategory)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByDomainAsc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByDomain(asc).list();
assertEquals("", results.get(0).getDomain());
classificationService.createClassificationQuery().orderByDomain(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getDomain)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByPriorityDesc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByPriority(desc).list();
assertEquals(999, results.get(0).getPriority());
classificationService.createClassificationQuery().orderByPriority(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.isSortedAccordingTo(
Comparator.comparingInt(ClassificationSummary::getPriority).reversed());
}
@Test
void testQueryForOrderByNameAsc() {
void testQueryForOrderByNameAsc_old() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByName(asc).list();
assertEquals("Beratungsprotokoll", results.get(0).getName());
classificationService.createClassificationQuery().orderByName(ASCENDING).list();
assertThat(results.get(0).getName()).isEqualTo("Beratungsprotokoll");
}
@Test
@Disabled("due to https://taskana.atlassian.net/browse/TSK-1197")
void testQueryForOrderByNameAsc() {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByName(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getName)
.isSortedAccordingTo(Collator.getInstance(Locale.GERMANY));
}
@Test
void testQueryForOrderByServiceLevelDesc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().orderByServiceLevel(desc).list();
assertEquals("P8D", results.get(0).getServiceLevel());
classificationService.createClassificationQuery().orderByServiceLevel(DESCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getServiceLevel)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByApplicationEntryPointAsc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByApplicationEntryPoint(asc)
.orderByName(asc)
.orderByApplicationEntryPoint(ASCENDING)
.list();
assertEquals(
"CLI:100000000000000000000000000000000007", results.get(results.size() - 6).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getApplicationEntryPoint)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByParentKeyAsc() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByParentKey(asc)
.orderByDomain(asc)
.list();
assertEquals(
"CLI:000000000000000000000000000000000019", results.get(results.size() - 5).getId());
classificationService.createClassificationQuery().orderByParentKey(ASCENDING).list();
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getParentKey)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByCustom1Desc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("1", desc)
.orderByDomain(asc)
.orderByServiceLevel(desc)
.orderByCustomAttribute("1", DESCENDING)
.list();
assertEquals("CLI:000000000000000000000000000000000002", results.get(0).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom1)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByCustom2Asc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("2", asc)
.orderByName(asc)
.orderByParentKey(asc)
.orderByDomain(asc)
.orderByCustomAttribute("2", ASCENDING)
.list();
assertEquals("CLI:000000000000000000000000000000000002", results.get(0).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom2)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByCustom3Desc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("3", desc)
.orderByName(asc)
.orderByCustomAttribute("3", DESCENDING)
.list();
assertEquals("CLI:100000000000000000000000000000000014", results.get(0).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom3)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByCustom4Asc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("4", asc)
.orderByName(asc)
.orderByCustomAttribute("4", ASCENDING)
.list();
assertEquals(
"CLI:100000000000000000000000000000000010", results.get(results.size() - 5).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom4)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByCustom5Desc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("5", desc)
.orderByName(asc)
.orderByCustomAttribute("5", DESCENDING)
.list();
assertEquals("CLI:100000000000000000000000000000000011", results.get(0).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom5)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByCustom6Asc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("6", asc)
.orderByName(asc)
.orderByCustomAttribute("6", ASCENDING)
.list();
assertEquals(
"CLI:100000000000000000000000000000000010", results.get(results.size() - 4).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom6)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@Test
void testQueryForOrderByCustom7Desc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("7", desc)
.orderByName(asc)
.orderByCustomAttribute("7", DESCENDING)
.list();
assertEquals("CLI:100000000000000000000000000000000011", results.get(0).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom7)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@Test
void testQueryForOrderByCustom8Asc() throws InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
.orderByCustomAttribute("8", asc)
.orderByName(asc)
.orderByCustomAttribute("8", ASCENDING)
.list();
assertEquals(
"CLI:100000000000000000000000000000000010", results.get(results.size() - 4).getId());
assertThat(results)
.hasSizeGreaterThan(2)
.extracting(ClassificationSummary::getCustom8)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
}

29
lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationWithPaginationAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.classification;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -25,7 +24,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results).hasSize(5);
}
@Test
@ -33,7 +32,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
ClassificationService classificationService = taskanaEngine.getClassificationService();
List<ClassificationSummary> results =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list(5, 5);
assertThat(results.size(), equalTo(5));
assertThat(results).hasSize(5);
}
@Test
@ -43,15 +42,15 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
// both will be 0, working
List<ClassificationSummary> results =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list(-1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// limit will be 0
results = classificationService.createClassificationQuery().domainIn("DOMAIN_A").list(1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// offset will be 0
results = classificationService.createClassificationQuery().domainIn("DOMAIN_A").list(-1, 3);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@Test
@ -66,7 +65,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
// Getting full page
pageNumber = 3;
@ -76,7 +75,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
// Getting last results on 1 big page
pageNumber = 1;
@ -86,7 +85,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(17));
assertThat(results).hasSize(17);
// Getting last results on multiple pages
pageNumber = 2;
@ -96,7 +95,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(7));
assertThat(results).hasSize(7);
}
@Test
@ -111,7 +110,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative will be 0 = all results
pageNumber = 1;
@ -121,7 +120,7 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative page = first page
pageNumber = -1;
@ -131,13 +130,13 @@ class QueryClassificationWithPaginationAccTest extends AbstractAccTest {
.createClassificationQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(10));
assertThat(results).hasSize(10);
}
@Test
void testCountOfClassificationsQuery() {
ClassificationService classificationService = taskanaEngine.getClassificationService();
long count = classificationService.createClassificationQuery().domainIn("DOMAIN_A").count();
assertThat(count, equalTo(17L));
assertThat(count).isEqualTo(17L);
}
}

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

@ -1,12 +1,7 @@
package acceptance.classification;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
@ -14,7 +9,7 @@ import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -82,11 +77,11 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
// Get and check the new value
Classification updatedClassification =
classificationService.getClassification("T2100", "DOMAIN_A");
assertNotNull(updatedClassification);
assertThat(updatedClassification.getName(), equalTo(newName));
assertThat(updatedClassification.getApplicationEntryPoint(), equalTo(newEntryPoint));
assertThat(updatedClassification.getCreated(), equalTo(createdBefore));
assertTrue(modifiedBefore.isBefore(updatedClassification.getModified()));
assertThat(updatedClassification).isNotNull();
assertThat(updatedClassification.getName()).isEqualTo(newName);
assertThat(updatedClassification.getApplicationEntryPoint()).isEqualTo(newEntryPoint);
assertThat(updatedClassification.getCreated()).isEqualTo(createdBefore);
assertThat(modifiedBefore).isBefore(updatedClassification.getModified());
}
@Test
@ -113,9 +108,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
classification.setPriority(1000);
classification.setServiceLevel("P2DT3H4M");
Assertions.assertThrows(
NotAuthorizedException.class,
() -> classificationService.updateClassification(classification));
ThrowingCallable call = () -> classificationService.updateClassification(classification);
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -139,20 +133,15 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
TaskImpl updatedTask =
(TaskImpl)
taskanaEngine.getTaskService().getTask("TKI:000000000000000000000000000000000000");
assertThat(
updatedTask.getClassificationCategory(),
not(equalTo(beforeTask.getClassificationCategory())));
assertThat(
updatedTask.getClassificationSummary().getCategory(),
not(equalTo(beforeTask.getClassificationSummary().getCategory())));
assertThat(updatedTask.getClassificationCategory(), equalTo("PROCESS"));
assertThat(updatedTask.getClassificationSummary().getCategory(), equalTo("PROCESS"));
assertThat(classification.getCreated(), equalTo(createdBefore));
assertThat(beforeTask.getClassificationCategory())
.isNotEqualTo(updatedTask.getClassificationCategory());
assertThat(beforeTask.getClassificationSummary().getCategory())
.isNotEqualTo(updatedTask.getClassificationSummary().getCategory());
assertThat(updatedTask.getClassificationCategory()).isEqualTo("PROCESS");
assertThat(updatedTask.getClassificationSummary().getCategory()).isEqualTo("PROCESS");
assertThat(classification.getCreated()).isEqualTo(createdBefore);
// isBeforeOrEquals in case of too fast execution
assertTrue(
modifiedBefore.isBefore(classification.getModified())
|| modifiedBefore.equals(classification.getModified()));
assertThat(modifiedBefore).isBeforeOrEqualTo(classification.getModified());
}
@WithAccessId(
@ -175,10 +164,11 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
classification.setName("NOW IT´S MY TURN");
classification.setDescription("IT SHOULD BE TO LATE...");
Assertions.assertThrows(
ConcurrencyException.class,
() -> classificationService.updateClassification(classification),
"The Classification should not be updated, because it was modified while editing.");
ThrowingCallable call = () -> classificationService.updateClassification(classification);
assertThatThrownBy(call)
.isInstanceOf(ConcurrencyException.class)
.describedAs(
"The Classification should not be updated, because it was modified while editing.");
}
@WithAccessId(
@ -190,9 +180,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
InvalidArgumentException {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentId("ID WHICH CANT BE FOUND");
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.updateClassification(classification));
ThrowingCallable call = () -> classificationService.updateClassification(classification);
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@WithAccessId(
@ -204,10 +193,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
InvalidArgumentException {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentKey("KEY WHICH CANT BE FOUND");
Assertions.assertThrows(
ClassificationNotFoundException.class,
() -> classificationService.updateClassification(classification));
ThrowingCallable call = () -> classificationService.updateClassification(classification);
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
@WithAccessId(
@ -217,7 +204,6 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
public void testUpdateClassificationPrioServiceLevel()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InterruptedException, TaskNotFoundException, InvalidArgumentException {
String newEntryPoint = "updated EntryPoint";
final Instant before = Instant.now();
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
@ -229,9 +215,9 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
// Get and check the new value
Classification updatedClassification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
assertNotNull(updatedClassification);
assertThat(updatedClassification).isNotNull();
assertFalse(modifiedBefore.isAfter(updatedClassification.getModified()));
assertThat(modifiedBefore.isAfter(updatedClassification.getModified())).isFalse();
// TODO - resume old behaviour after attachment query is possible.
TaskService taskService = taskanaEngine.getTaskService();
@ -310,9 +296,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentKey(classification.getKey());
Assertions.assertThrows(
InvalidArgumentException.class,
() -> classificationService.updateClassification(classification));
ThrowingCallable call = () -> classificationService.updateClassification(classification);
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(
@ -349,8 +334,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
// Get and check the new value
Classification updatedClassification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
assertNotNull(updatedClassification);
assertFalse(modifiedBefore.isAfter(updatedClassification.getModified()));
assertThat(updatedClassification).isNotNull();
assertThat(modifiedBefore.isAfter(updatedClassification.getModified())).isFalse();
// TODO - resume old behaviour after attachment query is possible.
TaskService taskService = taskanaEngine.getTaskService();
WorkingDaysToDaysConverter.setGermanPublicHolidaysEnabled(true);
@ -489,8 +474,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
// Get and check the new value
Classification updatedClassification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
assertNotNull(updatedClassification);
assertFalse(modifiedBefore.isAfter(updatedClassification.getModified()));
assertThat(updatedClassification).isNotNull();
assertThat(modifiedBefore.isAfter(updatedClassification.getModified())).isFalse();
// TODO - resume old behaviour after attachment query is possible.
TaskService taskService = taskanaEngine.getTaskService();
WorkingDaysToDaysConverter.setGermanPublicHolidaysEnabled(true);
@ -580,15 +565,18 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
for (String taskId : tasksUpdated) {
Task task = taskService.getTask(taskId);
assertTrue(
task.getModified().isAfter(before), "Task " + task.getId() + " has not been refreshed.");
assertThat(task.getModified())
.describedAs("Task " + task.getId() + " has not been refreshed.")
.isAfter(before);
long calendarDays = converter.convertWorkingDaysToDays(task.getPlanned(), serviceLevel);
String msg =
String.format(
"Task: %s and Due Date: %s do not match planned %s. Calendar days : %s.",
taskId, task.getDue(), task.getPlanned(), calendarDays);
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(calendarDays)), msg);
assertThat(task.getDue())
.describedAs(msg)
.isEqualTo(task.getPlanned().plus(Duration.ofDays(calendarDays)));
}
}
}

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

@ -1,18 +1,19 @@
package acceptance.config;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import org.h2.store.fs.FileUtils;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.internal.TaskanaEngineImpl;
@ -25,6 +26,8 @@ import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
*/
class TaskanaConfigAccTest extends TaskanaEngineImpl {
@TempDir Path tempDir;
TaskanaConfigAccTest() throws SQLException {
super(
new TaskanaEngineConfiguration(
@ -35,54 +38,36 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
@Test
void testDomains() {
assertEquals(2, getConfiguration().getDomains().size());
assertTrue(getConfiguration().getDomains().contains("DOMAIN_A"));
assertTrue(getConfiguration().getDomains().contains("DOMAIN_B"));
assertFalse(getConfiguration().getDomains().contains("Domain_A"));
assertThat(getConfiguration().getDomains()).containsOnly("DOMAIN_A", "DOMAIN_B");
}
@Test
void testClassificationTypes() {
assertEquals(2, getConfiguration().getClassificationTypes().size());
assertTrue(getConfiguration().getClassificationTypes().contains("TASK"));
assertTrue(getConfiguration().getClassificationTypes().contains("DOCUMENT"));
assertFalse(getConfiguration().getClassificationTypes().contains("document"));
assertThat(getConfiguration().getClassificationTypes()).containsOnly("TASK", "DOCUMENT");
}
@Test
void testClassificationCategories() {
assertEquals(4, getConfiguration().getClassificationCategoriesByType("TASK").size());
assertTrue(getConfiguration().getClassificationCategoriesByType("TASK").contains("EXTERNAL"));
assertTrue(getConfiguration().getClassificationCategoriesByType("TASK").contains("MANUAL"));
assertTrue(getConfiguration().getClassificationCategoriesByType("TASK").contains("AUTOMATIC"));
assertTrue(getConfiguration().getClassificationCategoriesByType("TASK").contains("PROCESS"));
assertFalse(getConfiguration().getClassificationCategoriesByType("TASK").contains("manual"));
assertThat(getConfiguration().getClassificationCategoriesByType("TASK"))
.containsOnly("EXTERNAL", "MANUAL", "AUTOMATIC", "PROCESS");
}
@Test
void testDoesNotExistPropertyClassificationTypeOrItIsEmpty() throws IOException {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", false, true);
String propertiesFileName = createNewConfigFile("dummyTestConfig.properties", false, true);
String delimiter = ";";
try {
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
} finally {
deleteFile(propertiesFileName);
}
assertTrue(taskanaEngineConfiguration.getClassificationTypes().isEmpty());
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
assertThat(taskanaEngineConfiguration.getClassificationTypes()).isEmpty();
}
@Test
void testDoesNotExistPropertyClassificatioCategoryOrItIsEmpty() throws IOException {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
taskanaEngineConfiguration.setClassificationCategoriesByType(new HashMap<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", true, false);
String propertiesFileName = createNewConfigFile("dummyTestConfig.properties", true, false);
String delimiter = ";";
try {
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
} finally {
deleteFile(propertiesFileName);
}
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
assertThat(
taskanaEngineConfiguration.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(0)))
@ -93,62 +78,50 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
void testWithCategoriesAndClassificationFilled() throws IOException {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
taskanaEngineConfiguration.setClassificationCategoriesByType(new HashMap<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", true, true);
String propertiesFileName = createNewConfigFile("dummyTestConfig.properties", true, true);
String delimiter = ";";
try {
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
} finally {
deleteFile(propertiesFileName);
}
assertFalse(taskanaEngineConfiguration.getClassificationTypes().isEmpty());
assertFalse(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(0))
.isEmpty());
assertEquals(taskanaEngineConfiguration.getClassificationTypes().size(), 2);
assertEquals(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(0))
.size(),
4);
assertEquals(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(1))
.size(),
1);
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
assertThat(taskanaEngineConfiguration.getClassificationTypes().isEmpty()).isFalse();
assertThat(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(0))
.isEmpty())
.isFalse();
assertThat(taskanaEngineConfiguration.getClassificationTypes()).hasSize(2);
assertThat(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(0))
.size())
.isEqualTo(4);
assertThat(
taskanaEngineConfiguration
.getClassificationCategoriesByType(
taskanaEngineConfiguration.getClassificationTypes().get(1))
.size())
.isEqualTo(1);
}
private String createNewConfigFile(
String filename, boolean addingTypes, boolean addingClassification) throws IOException {
String userHomeDirectroy = System.getProperty("user.home");
String propertiesFileName = userHomeDirectroy + filename;
File f = new File(propertiesFileName);
if (!f.exists()) {
try (PrintWriter writer = new PrintWriter(propertiesFileName, "UTF-8")) {
writer.println("taskana.roles.Admin =Holger|Stefan");
writer.println("taskana.roles.businessadmin = ebe | konstantin ");
writer.println("taskana.roles.user = nobody");
if (addingTypes) {
writer.println("taskana.classification.types= TASK , document");
}
if (addingClassification) {
writer.println(
"taskana.classification.categories.task= EXTERNAL, manual, autoMAtic, Process");
writer.println("taskana.classification.categories.document= EXTERNAL");
}
}
Path file = Files.createFile(tempDir.resolve(filename));
List<String> lines =
Stream.of(
"taskana.roles.Admin =Holger|Stefan",
"taskana.roles.businessadmin = ebe | konstantin ",
"taskana.roles.user = nobody")
.collect(Collectors.toList());
if (addingTypes) {
lines.add("taskana.classification.types= TASK , document");
}
if (addingClassification) {
lines.add("taskana.classification.categories.task= EXTERNAL, manual, autoMAtic, Process");
lines.add("taskana.classification.categories.document= EXTERNAL");
}
return propertiesFileName;
}
private void deleteFile(String propertiesFileName) {
System.out.println("about to delete " + propertiesFileName);
File f = new File(propertiesFileName);
if (f.exists() && !f.isDirectory()) {
FileUtils.delete(propertiesFileName);
}
Files.write(file, lines, StandardCharsets.UTF_8);
return file.toString();
}
}

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

@ -1,14 +1,17 @@
package acceptance.config;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import org.h2.store.fs.FileUtils;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaRole;
@ -22,6 +25,8 @@ import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
*/
class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
@TempDir Path tempDir;
TaskanaRoleConfigAccTest() throws SQLException {
super(
new TaskanaEngineConfiguration(
@ -33,118 +38,83 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
@Test
void testStandardConfig() {
Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
assertTrue(rolesConfigured.contains(TaskanaRole.ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.BUSINESS_ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.USER));
assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
assertTrue(users.contains("user_1_1"));
assertTrue(users.contains("user_1_2"));
assertThat(users).contains("user_1_1", "user_1_2");
Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
assertTrue(admins.contains("name=konrad,organisation=novatec"));
assertTrue(admins.contains("admin"));
assertThat(admins).contains("name=konrad,organisation=novatec", "admin");
Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertTrue(businessAdmins.contains("max"));
assertTrue(businessAdmins.contains("moritz"));
assertThat(businessAdmins).contains("max", "moritz");
Set<String> monitorAccessIds = getConfiguration().getRoleMap().get(TaskanaRole.MONITOR);
assertTrue(monitorAccessIds.contains("john"));
assertTrue(monitorAccessIds.contains("teamlead_2"));
assertTrue(monitorAccessIds.contains("monitor"));
assertThat(monitorAccessIds).contains("teamlead_2", "monitor");
}
@Test
void testOtherConfigFileSameDelimiter() throws IOException {
String propertiesFileName = createNewConfigFileWithSameDelimiter("/dummyTestConfig.properties");
try {
getConfiguration().initTaskanaProperties(propertiesFileName, "|");
String propertiesFileName = createNewConfigFileWithSameDelimiter("dummyTestConfig.properties");
getConfiguration().initTaskanaProperties(propertiesFileName, "|");
Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
assertTrue(rolesConfigured.contains(TaskanaRole.ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.BUSINESS_ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.USER));
Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
assertTrue(users.contains("nobody"));
Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
assertThat(users).containsOnly("nobody");
Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
assertTrue(admins.contains("holger"));
assertTrue(admins.contains("stefan"));
Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
assertThat(admins).containsOnly("holger", "stefan");
Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertTrue(businessAdmins.contains("ebe"));
assertTrue(businessAdmins.contains("konstantin"));
} finally {
deleteFile(propertiesFileName);
}
Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertThat(businessAdmins).containsOnly("ebe", "konstantin");
}
@Test
void testOtherConfigFileDifferentDelimiter() throws IOException {
String delimiter = ";";
String propertiesFileName =
createNewConfigFileWithDifferentDelimiter("/dummyTestConfig.properties", delimiter);
try {
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
createNewConfigFileWithDifferentDelimiter("dummyTestConfig.properties", delimiter);
getConfiguration().initTaskanaProperties(propertiesFileName, delimiter);
Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
assertTrue(rolesConfigured.contains(TaskanaRole.ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.BUSINESS_ADMIN));
assertTrue(rolesConfigured.contains(TaskanaRole.USER));
Set<TaskanaRole> rolesConfigured = getConfiguration().getRoleMap().keySet();
assertThat(rolesConfigured).containsOnly(TaskanaRole.values());
Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
assertTrue(users.isEmpty());
Set<String> users = getConfiguration().getRoleMap().get(TaskanaRole.USER);
assertThat(users).isEmpty();
Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
assertTrue(admins.contains("holger"));
assertTrue(admins.contains("name=stefan,organisation=novatec"));
Set<String> admins = getConfiguration().getRoleMap().get(TaskanaRole.ADMIN);
assertThat(admins).containsOnly("holger", "name=stefan,organisation=novatec");
Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertTrue(businessAdmins.contains("name=ebe, ou = bpm"));
assertTrue(businessAdmins.contains("konstantin"));
} finally {
deleteFile(propertiesFileName);
}
Set<String> businessAdmins = getConfiguration().getRoleMap().get(TaskanaRole.BUSINESS_ADMIN);
assertThat(businessAdmins).containsOnly("name=ebe, ou = bpm", "konstantin");
}
private String createNewConfigFileWithDifferentDelimiter(String filename, String delimiter)
throws IOException {
String userHomeDirectroy = System.getProperty("user.home");
String propertiesFileName = userHomeDirectroy + filename;
File f = new File(propertiesFileName);
if (!f.exists()) {
try (PrintWriter writer = new PrintWriter(propertiesFileName, "UTF-8")) {
writer.println(
"taskana.roles.Admin =hOlGeR " + delimiter + "name=Stefan,Organisation=novatec");
writer.println(
" taskana.roles.businessadmin = name=ebe, ou = bpm " + delimiter + " konstantin ");
writer.println(" taskana.roles.user = ");
}
}
return propertiesFileName;
}
Path file = Files.createFile(tempDir.resolve(filename));
List<String> lines =
Arrays.asList(
"taskana.roles.Admin =hOlGeR " + delimiter + "name=Stefan,Organisation=novatec",
" taskana.roles.businessadmin = name=ebe, ou = bpm " + delimiter + " konstantin ",
" taskana.roles.user = ");
private void deleteFile(String propertiesFileName) {
System.out.println("about to delete " + propertiesFileName);
File f = new File(propertiesFileName);
if (f.exists() && !f.isDirectory()) {
FileUtils.delete(propertiesFileName);
}
Files.write(file, lines, StandardCharsets.UTF_8);
return file.toString();
}
private String createNewConfigFileWithSameDelimiter(String filename) throws IOException {
String userHomeDirectroy = System.getProperty("user.home");
String propertiesFileName = userHomeDirectroy + filename;
File f = new File(propertiesFileName);
if (!f.exists()) {
try (PrintWriter writer = new PrintWriter(propertiesFileName, "UTF-8")) {
writer.println("taskana.roles.Admin =hOlGeR|Stefan");
writer.println(" taskana.roles.businessadmin = ebe | konstantin ");
writer.println(" taskana.roles.user = nobody");
}
}
return propertiesFileName;
Path file = Files.createFile(tempDir.resolve(filename));
List<String> lines =
Arrays.asList(
"taskana.roles.Admin =hOlGeR|Stefan",
" taskana.roles.businessadmin = ebe | konstantin ",
" taskana.roles.user = nobody");
Files.write(file, lines, StandardCharsets.UTF_8);
return file.toString();
}
}

4
lib/taskana-core/src/test/java/acceptance/history/TaskEventProducerTest.java
View File

@ -1,6 +1,6 @@
package acceptance.history;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Test;
@ -10,6 +10,6 @@ class TaskEventProducerTest extends AbstractAccTest {
@Test
void testHistoryEventProducerIsNotEnabled() {
assertFalse(taskanaEngine.isHistoryEnabled());
assertThat(taskanaEngine.isHistoryEnabled()).isFalse();
}
}

13
lib/taskana-core/src/test/java/acceptance/jobs/TaskCleanupJobAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.jobs;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
@ -46,7 +45,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
createAndCompleteTask();
long totalTasksCount = taskService.createTaskQuery().count();
assertEquals(84, totalTasksCount);
assertThat(totalTasksCount).isEqualTo(84);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(false);
@ -54,14 +53,14 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
job.run();
totalTasksCount = taskService.createTaskQuery().count();
assertEquals(68, totalTasksCount);
assertThat(totalTasksCount).isEqualTo(68);
}
@WithAccessId(userName = "admin")
@Test
void shouldCleanCompletedTasksUntilDateWithSameParentBussiness() throws Exception {
long totalTasksCount = taskService.createTaskQuery().count();
assertEquals(83, totalTasksCount);
assertThat(totalTasksCount).isEqualTo(83);
taskanaEngine.getConfiguration().setTaskCleanupJobAllCompletedSameParentBusiness(true);
@ -80,7 +79,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
job.run();
totalTasksCount = taskService.createTaskQuery().count();
assertEquals(66, totalTasksCount);
assertThat(totalTasksCount).isEqualTo(66);
}
@WithAccessId(userName = "admin")
@ -92,7 +91,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
job.run();
Task completedCreatedTask = taskService.getTask(createdTask.getId());
assertNotNull(completedCreatedTask);
assertThat(completedCreatedTask).isNotNull();
}
private Task createAndCompleteTask()

19
lib/taskana-core/src/test/java/acceptance/jobs/WorkbasketCleanupJobAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.jobs;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -43,7 +42,7 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
@Test
void shouldCleanWorkbasketMarkedForDeletionWithoutTasks() throws TaskanaException {
long totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
assertEquals(25, totalWorkbasketCount);
assertThat(totalWorkbasketCount).isEqualTo(25);
List<WorkbasketSummary> workbaskets =
workbasketService
.createWorkbasketQuery()
@ -51,8 +50,8 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
.orderByKey(BaseQuery.SortDirection.ASCENDING)
.list();
assertEquals(getNumberTaskNotCompleted(workbaskets.get(0).getId()), 0);
assertEquals(getNumberTaskCompleted(workbaskets.get(0).getId()), 1);
assertThat(0).isEqualTo(getNumberTaskNotCompleted(workbaskets.get(0).getId()));
assertThat(1).isEqualTo(getNumberTaskCompleted(workbaskets.get(0).getId()));
// Workbasket with completed task will be marked for deletion.
workbasketService.deleteWorkbasket(workbaskets.get(0).getId());
@ -61,20 +60,20 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
TaskCleanupJob taskCleanupJob = new TaskCleanupJob(taskanaEngine, null, null);
taskCleanupJob.run();
assertEquals(getNumberTaskCompleted(workbaskets.get(0).getId()), 0);
assertThat(0).isEqualTo(getNumberTaskCompleted(workbaskets.get(0).getId()));
WorkbasketCleanupJob workbasketCleanupJob = new WorkbasketCleanupJob(taskanaEngine, null, null);
workbasketCleanupJob.run();
totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
assertEquals(24, totalWorkbasketCount);
assertThat(totalWorkbasketCount).isEqualTo(24);
}
@WithAccessId(userName = "admin")
@Test
void shouldNotCleanWorkbasketMarkedForDeletionIfWorkbasketHasTasks() throws Exception {
long totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
assertEquals(25, totalWorkbasketCount);
assertThat(totalWorkbasketCount).isEqualTo(25);
List<WorkbasketSummary> workbaskets =
workbasketService
.createWorkbasketQuery()
@ -82,7 +81,7 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
.orderByKey(BaseQuery.SortDirection.ASCENDING)
.list();
assertNotEquals(getNumberTaskCompleted(workbaskets.get(0).getId()), 0);
assertThat(0).isNotEqualTo(getNumberTaskCompleted(workbaskets.get(0).getId()));
// Workbasket with completed task will be marked for deletion.
workbasketService.deleteWorkbasket(workbaskets.get(0).getId());
@ -91,7 +90,7 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
job.run();
totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
assertEquals(25, totalWorkbasketCount);
assertThat(totalWorkbasketCount).isEqualTo(25);
}
private long getNumberTaskNotCompleted(String workbasketId) {

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

@ -1,7 +1,6 @@
package acceptance.objectreference;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.task.api.ObjectReferenceQueryColumnName.COMPANY;
import static pro.taskana.task.api.ObjectReferenceQueryColumnName.SYSTEM;
@ -23,14 +22,14 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
void testQueryObjectReferenceValuesForColumnName() {
TaskQuery taskQuery = taskanaEngine.getTaskService().createTaskQuery();
List<String> columnValues = taskQuery.createObjectReferenceQuery().listValues(COMPANY, null);
assertEquals(3, columnValues.size());
assertThat(columnValues).hasSize(3);
columnValues = taskQuery.createObjectReferenceQuery().listValues(SYSTEM, null);
assertEquals(3, columnValues.size());
assertThat(columnValues).hasSize(3);
columnValues =
taskQuery.createObjectReferenceQuery().systemIn("System1").listValues(SYSTEM, null);
assertEquals(1, columnValues.size());
assertThat(columnValues).hasSize(1);
}
@Test
@ -40,8 +39,8 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().companyIn("Company1", "Company2").list();
assertNotNull(objectReferenceList);
assertEquals(2, objectReferenceList.size());
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
@Test
@ -55,8 +54,8 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
.systemIn("System2")
.list();
assertNotNull(objectReferenceList);
assertEquals(1, objectReferenceList.size());
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(1);
}
@Test
@ -70,8 +69,8 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
.systemInstanceIn("Instance1")
.list();
assertNotNull(objectReferenceList);
assertEquals(1, objectReferenceList.size());
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(1);
}
@Test
@ -81,8 +80,8 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().typeIn("Type2", "Type3").list();
assertNotNull(objectReferenceList);
assertEquals(2, objectReferenceList.size());
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
@Test
@ -92,7 +91,7 @@ class QueryObjectReferenceAccTest extends AbstractAccTest {
List<ObjectReference> objectReferenceList =
taskQuery.createObjectReferenceQuery().valueIn("Value1", "Value3").list();
assertNotNull(objectReferenceList);
assertEquals(2, objectReferenceList.size());
assertThat(objectReferenceList).isNotNull();
assertThat(objectReferenceList).hasSize(2);
}
}

29
lib/taskana-core/src/test/java/acceptance/objectreference/QueryObjectreferencesWithPaginationAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.objectreference;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -38,28 +37,28 @@ class QueryObjectreferencesWithPaginationAccTest extends AbstractAccTest {
void testGetFirstPageOfObjectRefQueryWithOffset() {
List<ObjectReference> results = objRefQuery.list(0, 5);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@Test
void testGetSecondPageOfObjectRefQueryWithOffset() {
List<ObjectReference> results = objRefQuery.list(2, 5);
assertThat(results.size(), equalTo(1));
assertThat(results).hasSize(1);
}
@Test
void testListOffsetAndLimitOutOfBounds() {
// both will be 0, working
List<ObjectReference> results = objRefQuery.list(-1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// limit will be 0
results = objRefQuery.list(1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// offset will be 0
results = objRefQuery.list(-1, 3);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@Test
@ -68,25 +67,25 @@ class QueryObjectreferencesWithPaginationAccTest extends AbstractAccTest {
int pageNumber = 1;
int pageSize = 10;
List<ObjectReference> results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
// Getting full page
pageNumber = 2;
pageSize = 2;
results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(1));
assertThat(results).hasSize(1);
// Getting last results on 1 big page
pageNumber = 1;
pageSize = 100;
results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
// Getting last results on multiple pages
pageNumber = 2;
pageSize = 2;
results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(1));
assertThat(results).hasSize(1);
}
@Test
@ -95,24 +94,24 @@ class QueryObjectreferencesWithPaginationAccTest extends AbstractAccTest {
int pageNumber = 2;
int pageSize = 0;
List<ObjectReference> results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative will be 0 = all results
pageNumber = 2;
pageSize = -1;
results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative page = first page
pageNumber = -1;
pageSize = 10;
results = objRefQuery.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@Test
void testCountOfClassificationsQuery() {
long count = objRefQuery.count();
assertThat(count, equalTo(3L));
assertThat(count).isEqualTo(3L);
}
}

22
lib/taskana-core/src/test/java/acceptance/persistence/UpdateObjectsUseUtcTimeStampsAccTest.java
View File

@ -1,8 +1,6 @@
package acceptance.persistence;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
@ -74,7 +72,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
TimeZone.setDefault(TimeZone.getTimeZone("EST"));
Task retrievedTask = taskService.getTask(updatedTask.getId());
TimeZone.setDefault(originalZone);
assertEquals(updatedTask, retrievedTask);
assertThat(retrievedTask).isEqualTo(updatedTask);
}
@WithAccessId(
@ -114,7 +112,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
TimeZone.setDefault(TimeZone.getTimeZone("EST"));
Task readTask = taskService.getTask(createdTask.getId());
TimeZone.setDefault(originalZone);
assertEquals(createdTask, readTask);
assertThat(readTask).isEqualTo(createdTask);
}
@WithAccessId(
@ -136,7 +134,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
Classification retrievedClassification =
classificationService.getClassification(updatedClassification.getId());
TimeZone.setDefault(originalZone);
assertEquals(updatedClassification, retrievedClassification);
assertThat(retrievedClassification).isEqualTo(updatedClassification);
}
@WithAccessId(
@ -154,7 +152,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
// check only 1 created
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
assertThat(amountOfClassificationsAfter, equalTo(amountOfClassificationsBefore + 1));
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 1);
TimeZone originalZone = TimeZone.getDefault();
TimeZone.setDefault(TimeZone.getTimeZone("EST"));
@ -162,7 +160,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
classificationService.getClassification(classification.getId());
TimeZone.setDefault(originalZone);
assertEquals(classification, retrievedClassification);
assertThat(retrievedClassification).isEqualTo(classification);
}
@WithAccessId(
@ -182,7 +180,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
TimeZone.setDefault(TimeZone.getTimeZone("EST"));
Workbasket retrievedWorkbasket = workbasketService.getWorkbasket(updatedWorkbasket.getId());
TimeZone.setDefault(originalZone);
assertEquals(updatedWorkbasket, retrievedWorkbasket);
assertThat(retrievedWorkbasket).isEqualTo(updatedWorkbasket);
}
@WithAccessId(
@ -207,13 +205,13 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
workbasketService.createWorkbasketAccessItem(wbai);
int after = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();
assertEquals(before + 1, after);
assertThat(after).isEqualTo(before + 1);
TimeZone originalZone = TimeZone.getDefault();
TimeZone.setDefault(TimeZone.getTimeZone("EST"));
Workbasket retrievedWorkbasket = workbasketService.getWorkbasket("NT1234", "DOMAIN_A");
TimeZone.setDefault(originalZone);
assertEquals(workbasket, retrievedWorkbasket);
assertThat(retrievedWorkbasket).isEqualTo(workbasket);
}
@WithAccessId(
@ -249,6 +247,6 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
.orElse(null);
TimeZone.setDefault(originalZone);
assertEquals(job, retrievedJob);
assertThat(retrievedJob).isEqualTo(job);
}
}

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

@ -1,15 +1,14 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
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.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -26,13 +25,13 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService
.createWorkbasketReportBuilder()
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_2));
ThrowingCallable call =
() -> {
monitorService
.createWorkbasketReportBuilder()
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_2);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -46,10 +45,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
.workbasketIdIn(Collections.singletonList("WBI:000000000000000000000000000000000001"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_2);
assertNotNull(values);
assertEquals(2, values.size());
assertTrue(values.contains("Vollkasko"));
assertTrue(values.contains("Teilkasko"));
assertThat(values).containsOnly("Vollkasko", "Teilkasko");
}
@WithAccessId(userName = "monitor")
@ -62,8 +58,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
.createWorkbasketReportBuilder()
.domainIn(Collections.singletonList("DOMAIN_A"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_16);
assertNotNull(values);
assertEquals(26, values.size());
assertThat(values).hasSize(26);
}
@WithAccessId(userName = "monitor")
@ -81,8 +76,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
.customAttributeFilterIn(customAttributeFilter)
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_16);
assertNotNull(values);
assertEquals(12, values.size());
assertThat(values).hasSize(12);
}
@WithAccessId(userName = "monitor")
@ -90,10 +84,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
void testGetCustomAttributeValuesForExcludedClassifications() throws NotAuthorizedException {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = new ArrayList<>();
domains.add("DOMAIN_A");
domains.add("DOMAIN_B");
domains.add("DOMAIN_C");
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");
List<String> values =
monitorService
@ -103,7 +94,6 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
Collections.singletonList("CLI:000000000000000000000000000000000003"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_16);
assertNotNull(values);
assertEquals(43, values.size());
assertThat(values).hasSize(43);
}
}

121
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfCategoryReportAccTest.java
View File

@ -1,7 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -9,7 +9,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -32,13 +32,11 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<SelectedItem> selectedItems = new ArrayList<>();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService
.createCategoryReportBuilder()
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService.createCategoryReportBuilder().listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -75,18 +73,18 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.inWorkingDays()
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(11, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000021"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000022"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000023"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000026"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000028"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000032"));
assertThat(ids).hasSize(11);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000021")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000022")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000023")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000026")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000028")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000031")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000032")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -127,11 +125,11 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.workbasketIdIn(workbasketIds)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(4, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000026"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertThat(ids).hasSize(4);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000026")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000031")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -171,18 +169,18 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.stateIn(states)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(11, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000021"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000022"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000023"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000026"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000028"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000032"));
assertThat(ids).hasSize(11);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000021")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000022")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000023")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000026")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000028")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000031")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000032")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -216,10 +214,10 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.categoryIn(categories)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(3, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000032"));
assertThat(ids).hasSize(3);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000031")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000032")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -259,11 +257,11 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.domainIn(domains)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(4, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000021"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000022"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000028"));
assertThat(ids).hasSize(4);
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000021")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000022")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000028")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -304,12 +302,12 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
.customAttributeFilterIn(customAttributeFilter)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(5, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000032"));
assertThat(ids).hasSize(5);
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000031")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000032")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -328,13 +326,14 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
s1.setUpperAgeLimit(-2);
selectedItems.add(s1);
Assertions.assertThrows(
InvalidArgumentException.class,
() ->
monitorService
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,11 +1,11 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -45,12 +45,13 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
s3.setUpperAgeLimit(-11);
selectedItems.add(s3);
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService
.createClassificationReportBuilder()
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService
.createClassificationReportBuilder()
.listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -88,13 +89,13 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
.inWorkingDays()
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(6, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000001"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000004"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000007"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000010"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000033"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertThat(ids).hasSize(6);
assertThat(ids.contains("TKI:000000000000000000000000000000000001")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000004")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000007")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000010")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000033")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -134,9 +135,9 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
.inWorkingDays()
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(2, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000001"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000033"));
assertThat(ids).hasSize(2);
assertThat(ids.contains("TKI:000000000000000000000000000000000001")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000033")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -179,10 +180,10 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
.domainIn(domains)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(3, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000001"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000004"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertThat(ids).hasSize(3);
assertThat(ids.contains("TKI:000000000000000000000000000000000001")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000004")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

105
lib/taskana-core/src/test/java/acceptance/report/GetTaskIdsOfCustomFieldValueReportAccTest.java
View File

@ -1,7 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -9,7 +9,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -33,12 +33,13 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
List<SelectedItem> selectedItems = new ArrayList<>();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService
.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1)
.listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -76,15 +77,16 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.inWorkingDays()
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(8, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000002"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000029"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000033"));
assertThat(ids)
.containsOnly(
"TKI:000000000000000000000000000000000002",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000020",
"TKI:000000000000000000000000000000000024",
"TKI:000000000000000000000000000000000027",
"TKI:000000000000000000000000000000000029",
"TKI:000000000000000000000000000000000033");
}
@WithAccessId(userName = "monitor")
@ -125,10 +127,10 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.workbasketIdIn(workbasketIds)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(3, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertThat(ids).hasSize(3);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000009")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -167,15 +169,15 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.stateIn(Collections.singletonList(TaskState.READY))
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(8, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000002"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000029"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000033"));
assertThat(ids).hasSize(8);
assertThat(ids.contains("TKI:000000000000000000000000000000000002")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000009")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000029")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000033")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -215,10 +217,10 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.categoryIn(categories)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(3, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000029"));
assertThat(ids).hasSize(3);
assertThat(ids.contains("TKI:000000000000000000000000000000000006")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000009")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000029")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -257,10 +259,10 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.domainIn(Collections.singletonList("DOMAIN_A"))
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(3, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000033"));
assertThat(ids).hasSize(3);
assertThat(ids.contains("TKI:000000000000000000000000000000000009")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000033")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -301,11 +303,11 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
.customAttributeFilterIn(customAttributeFilter)
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(4, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000020"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000024"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000027"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000029"));
assertThat(ids).hasSize(4);
assertThat(ids.contains("TKI:000000000000000000000000000000000020")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000024")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000027")).isTrue();
assertThat(ids.contains("TKI:000000000000000000000000000000000029")).isTrue();
}
@WithAccessId(userName = "monitor")
@ -324,13 +326,14 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
s1.setUpperAgeLimit(-2);
selectedItems.add(s1);
Assertions.assertThrows(
InvalidArgumentException.class,
() ->
monitorService
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService
.createCategoryReportBuilder()
.withColumnHeaders(columnHeaders)
.listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,12 +1,12 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -28,12 +28,11 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
List<SelectedItem> selectedItems = new ArrayList<>();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService
.createWorkbasketReportBuilder()
.listTaskIdsForSelectedItems(selectedItems));
ThrowingCallable call =
() -> {
monitorService.createWorkbasketReportBuilder().listTaskIdsForSelectedItems(selectedItems);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -70,14 +69,15 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
.inWorkingDays()
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(7, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000001"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000004"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000010"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000050"));
assertThat(ids)
.containsOnly(
"TKI:000000000000000000000000000000000001",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000010",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000050");
}
@WithAccessId(userName = "monitor")
@ -117,11 +117,13 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
Collections.singletonList("CLI:000000000000000000000000000000000001"))
.listTaskIdsForSelectedItems(selectedItems);
assertEquals(4, ids.size());
assertTrue(ids.contains("TKI:000000000000000000000000000000000006"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000009"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000031"));
assertTrue(ids.contains("TKI:000000000000000000000000000000000050"));
assertThat(ids).hasSize(4);
assertThat(ids)
.containsOnly(
"TKI:000000000000000000000000000000000006",
"TKI:000000000000000000000000000000000009",
"TKI:000000000000000000000000000000000031",
"TKI:000000000000000000000000000000000050");
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

120
lib/taskana-core/src/test/java/acceptance/report/ProvideCategoryReportAccTest.java
View File

@ -1,8 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -11,7 +10,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
@ -37,9 +36,14 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> monitorService.createCategoryReportBuilder().buildReport());
// Assertions.assertThrows(
// NotAuthorizedException.class,
// () -> monitorService.createCategoryReportBuilder().buildReport());
ThrowingCallable call =
() -> {
monitorService.createCategoryReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -54,16 +58,16 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(33, report.getRow("EXTERN").getTotalValue());
assertEquals(7, report.getRow("AUTOMATIC").getTotalValue());
assertEquals(10, report.getRow("MANUAL").getTotalValue());
assertEquals(0, report.getRow("EXTERN").getCells().length);
assertEquals(0, report.getRow("AUTOMATIC").getCells().length);
assertEquals(0, report.getRow("MANUAL").getCells().length);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getRow("EXTERN").getTotalValue()).isEqualTo(33);
assertThat(report.getRow("AUTOMATIC").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("EXTERN").getCells().length).isEqualTo(0);
assertThat(report.getRow("AUTOMATIC").getCells().length).isEqualTo(0);
assertThat(report.getRow("MANUAL").getCells().length).isEqualTo(0);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -87,17 +91,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(33, report.getRow("EXTERN").getTotalValue());
assertEquals(7, report.getRow("AUTOMATIC").getTotalValue());
assertEquals(10, report.getRow("MANUAL").getTotalValue());
assertThat(report.getRow("EXTERN").getTotalValue()).isEqualTo(33);
assertThat(report.getRow("AUTOMATIC").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("MANUAL").getTotalValue()).isEqualTo(10);
int[] sumRow = report.getSumRow().getCells();
assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow);
assertEquals(50, report.getSumRow().getTotalValue());
assertEquals(50, sumLineCount);
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -118,17 +122,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {15, 8, 2, 6, 2}, row1);
assertThat(row1).isEqualTo(new int[] {15, 8, 2, 6, 2});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row2);
assertThat(row2).isEqualTo(new int[] {2, 1, 0, 1, 3});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row3);
assertThat(row3).isEqualTo(new int[] {2, 2, 2, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -146,17 +150,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {23, 0, 2, 0, 8}, row1);
assertThat(row1).isEqualTo(new int[] {23, 0, 2, 0, 8});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {3, 0, 0, 0, 4}, row2);
assertThat(row2).isEqualTo(new int[] {3, 0, 0, 0, 4});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {4, 0, 2, 0, 4}, row3);
assertThat(row3).isEqualTo(new int[] {4, 0, 2, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -181,17 +185,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {10, 2, 0, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {10, 2, 0, 0, 0});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 1}, row2);
assertThat(row2).isEqualTo(new int[] {2, 1, 0, 1, 1});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {1, 0, 1, 0, 1}, row3);
assertThat(row3).isEqualTo(new int[] {1, 0, 1, 0, 1});
}
@WithAccessId(userName = "monitor")
@ -215,17 +219,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {15, 8, 2, 6, 0}, row1);
assertThat(row1).isEqualTo(new int[] {15, 8, 2, 6, 0});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {2, 1, 0, 1, 0});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 0}, row3);
assertThat(row3).isEqualTo(new int[] {2, 2, 2, 0, 0});
}
@WithAccessId(userName = "monitor")
@ -249,14 +253,14 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
int[] row1 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row1);
assertThat(row1).isEqualTo(new int[] {2, 1, 0, 1, 3});
int[] row2 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row2);
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -280,17 +284,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {8, 4, 2, 4, 0}, row1);
assertThat(row1).isEqualTo(new int[] {8, 4, 2, 4, 0});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row2);
assertThat(row2).isEqualTo(new int[] {1, 0, 0, 1, 1});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {2, 0, 0, 0, 3}, row3);
assertThat(row3).isEqualTo(new int[] {2, 0, 0, 0, 3});
}
@WithAccessId(userName = "monitor")
@ -315,17 +319,17 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("EXTERN").getCells();
assertArrayEquals(new int[] {9, 3, 1, 3, 0}, row1);
assertThat(row1).isEqualTo(new int[] {9, 3, 1, 3, 0});
int[] row2 = report.getRow("AUTOMATIC").getCells();
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row2);
assertThat(row2).isEqualTo(new int[] {1, 0, 0, 1, 1});
int[] row3 = report.getRow("MANUAL").getCells();
assertArrayEquals(new int[] {1, 1, 2, 0, 2}, row3);
assertThat(row3).isEqualTo(new int[] {1, 1, 2, 0, 2});
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,8 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -11,7 +10,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
@ -38,9 +37,11 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
void testRoleCheck() throws InvalidArgumentException, NotAuthorizedException {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> monitorService.createClassificationReportBuilder().buildReport());
ThrowingCallable call =
() -> {
monitorService.createClassificationReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -55,20 +56,20 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
assertEquals(10, report.getRow("L10000").getTotalValue());
assertEquals(10, report.getRow("L20000").getTotalValue());
assertEquals(7, report.getRow("L30000").getTotalValue());
assertEquals(10, report.getRow("L40000").getTotalValue());
assertEquals(13, report.getRow("L50000").getTotalValue());
assertEquals(0, report.getRow("L10000").getCells().length);
assertEquals(0, report.getRow("L20000").getCells().length);
assertEquals(0, report.getRow("L30000").getCells().length);
assertEquals(0, report.getRow("L40000").getCells().length);
assertEquals(0, report.getRow("L50000").getCells().length);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(13);
assertThat(report.getRow("L10000").getCells().length).isEqualTo(0);
assertThat(report.getRow("L20000").getCells().length).isEqualTo(0);
assertThat(report.getRow("L30000").getCells().length).isEqualTo(0);
assertThat(report.getRow("L40000").getCells().length).isEqualTo(0);
assertThat(report.getRow("L50000").getCells().length).isEqualTo(0);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -92,26 +93,26 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
assertEquals(10, report.getRow("L10000").getTotalValue());
assertEquals(10, report.getRow("L20000").getTotalValue());
assertEquals(7, report.getRow("L30000").getTotalValue());
assertEquals(10, report.getRow("L40000").getTotalValue());
assertEquals(13, report.getRow("L50000").getTotalValue());
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(13);
assertEquals(10, report.getSumRow().getCells()[0]);
assertEquals(9, report.getSumRow().getCells()[1]);
assertEquals(11, report.getSumRow().getCells()[2]);
assertEquals(0, report.getSumRow().getCells()[3]);
assertEquals(4, report.getSumRow().getCells()[4]);
assertEquals(0, report.getSumRow().getCells()[5]);
assertEquals(7, report.getSumRow().getCells()[6]);
assertEquals(4, report.getSumRow().getCells()[7]);
assertEquals(5, report.getSumRow().getCells()[8]);
assertEquals(50, report.getSumRow().getTotalValue());
assertEquals(50, sumLineCount);
assertThat(report.getSumRow().getCells()[0]).isEqualTo(10);
assertThat(report.getSumRow().getCells()[1]).isEqualTo(9);
assertThat(report.getSumRow().getCells()[2]).isEqualTo(11);
assertThat(report.getSumRow().getCells()[3]).isEqualTo(0);
assertThat(report.getSumRow().getCells()[4]).isEqualTo(4);
assertThat(report.getSumRow().getCells()[5]).isEqualTo(0);
assertThat(report.getSumRow().getCells()[6]).isEqualTo(7);
assertThat(report.getSumRow().getCells()[7]).isEqualTo(4);
assertThat(report.getSumRow().getCells()[8]).isEqualTo(5);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -133,23 +134,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {7, 2, 1, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {7, 2, 1, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {5, 3, 1, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {5, 3, 1, 1, 0});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row3);
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 1, 3});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row4);
assertThat(row4).isEqualTo(new int[] {2, 2, 2, 0, 4});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {3, 3, 0, 5, 2}, row5);
assertThat(row5).isEqualTo(new int[] {3, 3, 0, 5, 2});
}
@WithAccessId(userName = "monitor")
@ -170,23 +171,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {9, 0, 1, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {9, 0, 1, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {8, 0, 1, 0, 1}, row2);
assertThat(row2).isEqualTo(new int[] {8, 0, 1, 0, 1});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {3, 0, 0, 0, 4}, row3);
assertThat(row3).isEqualTo(new int[] {3, 0, 0, 0, 4});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {4, 0, 2, 0, 4}, row4);
assertThat(row4).isEqualTo(new int[] {4, 0, 2, 0, 4});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {6, 0, 0, 0, 7}, row5);
assertThat(row5).isEqualTo(new int[] {6, 0, 0, 0, 7});
}
@WithAccessId(userName = "monitor")
@ -211,23 +212,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {6, 0, 0, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {6, 0, 0, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, row2);
assertThat(row2).isEqualTo(new int[] {2, 0, 0, 0, 0});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 1}, row3);
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 1, 1});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {1, 0, 1, 0, 1}, row4);
assertThat(row4).isEqualTo(new int[] {1, 0, 1, 0, 1});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {2, 2, 0, 0, 0}, row5);
assertThat(row5).isEqualTo(new int[] {2, 2, 0, 0, 0});
}
@WithAccessId(userName = "monitor")
@ -251,23 +252,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {7, 2, 1, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {7, 2, 1, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {5, 3, 1, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {5, 3, 1, 1, 0});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 0}, row3);
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 1, 0});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 0}, row4);
assertThat(row4).isEqualTo(new int[] {2, 2, 2, 0, 0});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {3, 3, 0, 5, 0}, row5);
assertThat(row5).isEqualTo(new int[] {3, 3, 0, 5, 0});
}
@WithAccessId(userName = "monitor")
@ -291,14 +292,14 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
int[] row1 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, row1);
assertThat(row1).isEqualTo(new int[] {2, 1, 0, 1, 3});
int[] row2 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, row2);
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -322,23 +323,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {5, 2, 1, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {5, 2, 1, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {3, 1, 1, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {3, 1, 1, 1, 0});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row3);
assertThat(row3).isEqualTo(new int[] {1, 0, 0, 1, 1});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {2, 0, 0, 0, 3}, row4);
assertThat(row4).isEqualTo(new int[] {2, 0, 0, 0, 3});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {0, 1, 0, 3, 0}, row5);
assertThat(row5).isEqualTo(new int[] {0, 1, 0, 3, 0});
}
@WithAccessId(userName = "monitor")
@ -363,23 +364,23 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
int[] row1 = report.getRow("L10000").getCells();
assertArrayEquals(new int[] {4, 0, 0, 0, 0}, row1);
assertThat(row1).isEqualTo(new int[] {4, 0, 0, 0, 0});
int[] row2 = report.getRow("L20000").getCells();
assertArrayEquals(new int[] {4, 1, 1, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {4, 1, 1, 1, 0});
int[] row3 = report.getRow("L30000").getCells();
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, row3);
assertThat(row3).isEqualTo(new int[] {1, 0, 0, 1, 1});
int[] row4 = report.getRow("L40000").getCells();
assertArrayEquals(new int[] {1, 1, 2, 0, 2}, row4);
assertThat(row4).isEqualTo(new int[] {1, 1, 2, 0, 2});
int[] row5 = report.getRow("L50000").getCells();
assertArrayEquals(new int[] {1, 2, 0, 2, 0}, row5);
assertThat(row5).isEqualTo(new int[] {1, 2, 0, 2, 0});
}
private List<TimeIntervalColumnHeader> getListOfColumnsHeaders() {

128
lib/taskana-core/src/test/java/acceptance/report/ProvideCustomFieldValueReportAccTest.java
View File

@ -1,8 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -10,7 +9,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
@ -37,10 +36,11 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
monitorService.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport());
ThrowingCallable call =
() -> {
monitorService.createCustomFieldValueReportBuilder(CustomField.CUSTOM_1).buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -56,17 +56,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(25, report.getRow("Geschaeftsstelle A").getTotalValue());
assertEquals(10, report.getRow("Geschaeftsstelle B").getTotalValue());
assertEquals(15, report.getRow("Geschaeftsstelle C").getTotalValue());
assertEquals(0, report.getRow("Geschaeftsstelle A").getCells().length);
assertEquals(0, report.getRow("Geschaeftsstelle B").getCells().length);
assertEquals(0, report.getRow("Geschaeftsstelle C").getCells().length);
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(25);
assertThat(report.getRow("Geschaeftsstelle B").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("Geschaeftsstelle C").getTotalValue()).isEqualTo(15);
assertThat(report.getRow("Geschaeftsstelle A").getCells().length).isEqualTo(0);
assertThat(report.getRow("Geschaeftsstelle B").getCells().length).isEqualTo(0);
assertThat(report.getRow("Geschaeftsstelle C").getCells().length).isEqualTo(0);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -82,16 +82,16 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
assertEquals(21, report.getRow("Vollkasko").getTotalValue());
assertEquals(29, report.getRow("Teilkasko").getTotalValue());
assertThat(report.getRow("Vollkasko").getTotalValue()).isEqualTo(21);
assertThat(report.getRow("Teilkasko").getTotalValue()).isEqualTo(29);
assertEquals(0, report.getRow("Vollkasko").getCells().length);
assertEquals(0, report.getRow("Teilkasko").getCells().length);
assertThat(report.getRow("Vollkasko").getCells().length).isEqualTo(0);
assertThat(report.getRow("Teilkasko").getCells().length).isEqualTo(0);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -114,16 +114,16 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(25, report.getRow("Geschaeftsstelle A").getTotalValue());
assertEquals(10, report.getRow("Geschaeftsstelle B").getTotalValue());
assertEquals(15, report.getRow("Geschaeftsstelle C").getTotalValue());
assertThat(report.getRow("Geschaeftsstelle A").getTotalValue()).isEqualTo(25);
assertThat(report.getRow("Geschaeftsstelle B").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("Geschaeftsstelle C").getTotalValue()).isEqualTo(15);
assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, report.getSumRow().getCells());
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -145,17 +145,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {11, 4, 3, 4, 3}, row1);
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 3});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {5, 3, 0, 2, 0}, row2);
assertThat(row2).isEqualTo(new int[] {5, 3, 0, 2, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {3, 4, 1, 1, 6}, row3);
assertThat(row3).isEqualTo(new int[] {3, 4, 1, 1, 6});
}
@WithAccessId(userName = "monitor")
@ -176,17 +176,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {15, 0, 3, 0, 7}, row1);
assertThat(row1).isEqualTo(new int[] {15, 0, 3, 0, 7});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {8, 0, 0, 0, 2}, row2);
assertThat(row2).isEqualTo(new int[] {8, 0, 0, 0, 2});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {7, 0, 1, 0, 7}, row3);
assertThat(row3).isEqualTo(new int[] {7, 0, 1, 0, 7});
}
@WithAccessId(userName = "monitor")
@ -211,17 +211,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {6, 1, 1, 1, 1}, row1);
assertThat(row1).isEqualTo(new int[] {6, 1, 1, 1, 1});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {4, 1, 0, 0, 0}, row2);
assertThat(row2).isEqualTo(new int[] {4, 1, 0, 0, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {3, 1, 0, 0, 1}, row3);
assertThat(row3).isEqualTo(new int[] {3, 1, 0, 0, 1});
}
@WithAccessId(userName = "monitor")
@ -245,17 +245,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {11, 4, 3, 4, 0}, row1);
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 0});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {5, 3, 0, 2, 0}, row2);
assertThat(row2).isEqualTo(new int[] {5, 3, 0, 2, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {3, 4, 1, 1, 0}, row3);
assertThat(row3).isEqualTo(new int[] {3, 4, 1, 1, 0});
}
@WithAccessId(userName = "monitor")
@ -279,17 +279,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {2, 1, 2, 1, 3}, row1);
assertThat(row1).isEqualTo(new int[] {2, 1, 2, 1, 3});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, row2);
assertThat(row2).isEqualTo(new int[] {2, 0, 0, 0, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {0, 2, 0, 0, 4}, row3);
assertThat(row3).isEqualTo(new int[] {0, 2, 0, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -313,17 +313,17 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {8, 1, 1, 4, 1}, row1);
assertThat(row1).isEqualTo(new int[] {8, 1, 1, 4, 1});
int[] row2 = report.getRow("Geschaeftsstelle B").getCells();
assertArrayEquals(new int[] {2, 2, 0, 1, 0}, row2);
assertThat(row2).isEqualTo(new int[] {2, 2, 0, 1, 0});
int[] row3 = report.getRow("Geschaeftsstelle C").getCells();
assertArrayEquals(new int[] {1, 1, 1, 0, 3}, row3);
assertThat(row3).isEqualTo(new int[] {1, 1, 1, 0, 3});
}
@WithAccessId(userName = "monitor")
@ -348,11 +348,11 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(1, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
int[] row1 = report.getRow("Geschaeftsstelle A").getCells();
assertArrayEquals(new int[] {11, 4, 3, 4, 3}, row1);
assertThat(row1).isEqualTo(new int[] {11, 4, 3, 4, 3});
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,8 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -10,7 +9,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
@ -40,9 +39,11 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> monitorService.createClassificationReportBuilder().buildDetailedReport());
ThrowingCallable call =
() -> {
monitorService.createClassificationReportBuilder().buildDetailedReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -58,44 +59,44 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> row1 = report.getRow("L10000");
assertEquals(10, row1.getTotalValue());
assertEquals(3, row1.getFoldableRow("L11000").getTotalValue());
assertEquals(7, row1.getFoldableRow("N/A").getTotalValue());
assertEquals(0, row1.getCells().length);
assertEquals(2, row1.getFoldableRowCount());
assertThat(row1.getTotalValue()).isEqualTo(10);
assertThat(row1.getFoldableRow("L11000").getTotalValue()).isEqualTo(3);
assertThat(row1.getFoldableRow("N/A").getTotalValue()).isEqualTo(7);
assertThat(row1.getCells().length).isEqualTo(0);
assertThat(row1.getFoldableRowCount()).isEqualTo(2);
FoldableRow<DetailedMonitorQueryItem> row2 = report.getRow("L20000");
assertEquals(10, row2.getTotalValue());
assertEquals(4, row2.getFoldableRow("L22000").getTotalValue());
assertEquals(6, row2.getFoldableRow("N/A").getTotalValue());
assertEquals(0, row2.getCells().length);
assertEquals(2, row2.getFoldableRowCount());
assertThat(row2.getTotalValue()).isEqualTo(10);
assertThat(row2.getFoldableRow("L22000").getTotalValue()).isEqualTo(4);
assertThat(row2.getFoldableRow("N/A").getTotalValue()).isEqualTo(6);
assertThat(row2.getCells().length).isEqualTo(0);
assertThat(row2.getFoldableRowCount()).isEqualTo(2);
FoldableRow<DetailedMonitorQueryItem> row3 = report.getRow("L30000");
assertEquals(7, row3.getTotalValue());
assertEquals(3, row3.getFoldableRow("L33000").getTotalValue());
assertEquals(1, row3.getFoldableRow("L99000").getTotalValue());
assertEquals(3, row3.getFoldableRow("N/A").getTotalValue());
assertEquals(0, row3.getCells().length);
assertEquals(3, row3.getFoldableRowCount());
assertThat(row3.getTotalValue()).isEqualTo(7);
assertThat(row3.getFoldableRow("L33000").getTotalValue()).isEqualTo(3);
assertThat(row3.getFoldableRow("L99000").getTotalValue()).isEqualTo(1);
assertThat(row3.getFoldableRow("N/A").getTotalValue()).isEqualTo(3);
assertThat(row3.getCells().length).isEqualTo(0);
assertThat(row3.getFoldableRowCount()).isEqualTo(3);
FoldableRow<DetailedMonitorQueryItem> row4 = report.getRow("L40000");
assertEquals(10, row4.getTotalValue());
assertEquals(10, row4.getFoldableRow("N/A").getTotalValue());
assertEquals(0, row4.getCells().length);
assertEquals(1, row4.getFoldableRowCount());
assertThat(row4.getTotalValue()).isEqualTo(10);
assertThat(row4.getFoldableRow("N/A").getTotalValue()).isEqualTo(10);
assertThat(row4.getCells().length).isEqualTo(0);
assertThat(row4.getFoldableRowCount()).isEqualTo(1);
FoldableRow<DetailedMonitorQueryItem> row5 = report.getRow("L50000");
assertEquals(13, row5.getTotalValue());
assertEquals(13, row5.getFoldableRow("N/A").getTotalValue());
assertEquals(0, row5.getCells().length);
assertEquals(1, row5.getFoldableRowCount());
assertThat(row5.getTotalValue()).isEqualTo(13);
assertThat(row5.getFoldableRow("N/A").getTotalValue()).isEqualTo(13);
assertThat(row5.getCells().length).isEqualTo(0);
assertThat(row5.getFoldableRowCount()).isEqualTo(1);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -117,18 +118,18 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
assertEquals(10, report.getRow("L10000").getTotalValue());
assertEquals(10, report.getRow("L20000").getTotalValue());
assertEquals(7, report.getRow("L30000").getTotalValue());
assertEquals(10, report.getRow("L40000").getTotalValue());
assertEquals(13, report.getRow("L50000").getTotalValue());
assertThat(report.getRow("L10000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L20000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L30000").getTotalValue()).isEqualTo(7);
assertThat(report.getRow("L40000").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("L50000").getTotalValue()).isEqualTo(13);
int[] sumRow = report.getSumRow().getCells();
assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -150,50 +151,50 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {7, 2, 1, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {7, 2, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {2, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {5, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {5, 2, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {5, 3, 1, 1, 0}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {5, 3, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {1, 1, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {4, 2, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {2, 1, 0, 1, 3});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine3a.getCells());
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {0, 1, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLine3b = line3.getFoldableRow("L99000");
assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine3b.getCells());
assertThat(detailedLine3b.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 1});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {3, 3, 0, 5, 2}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {3, 3, 0, 5, 2});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {3, 3, 0, 5, 2}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {3, 3, 0, 5, 2});
}
@WithAccessId(userName = "monitor")
@ -218,47 +219,47 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {6, 0, 0, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {6, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {4, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {4, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {2, 1, 0, 1, 1}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {2, 1, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine3a.getCells());
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {0, 1, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {1, 0, 1, 0, 1}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {1, 0, 1, 0, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 0, 1, 0, 1}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {1, 0, 1, 0, 1});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {2, 2, 0, 0, 0}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {2, 2, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 2, 0, 0, 0}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {2, 2, 0, 0, 0});
}
@WithAccessId(userName = "monitor")
@ -282,47 +283,47 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {7, 2, 1, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {7, 2, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {2, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {5, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {5, 2, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {5, 3, 1, 1, 0}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {5, 3, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {1, 1, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {4, 2, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {2, 1, 0, 1, 0}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {2, 1, 0, 1, 0});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 1, 0, 1, 0}, detailedLine3a.getCells());
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {0, 1, 0, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {2, 2, 2, 0, 0}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 2, 2, 0, 0}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {3, 3, 0, 5, 0}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {3, 3, 0, 5, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {3, 3, 0, 5, 0}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {3, 3, 0, 5, 0});
}
@WithAccessId(userName = "monitor")
@ -343,50 +344,50 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {9, 0, 1, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {9, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {2, 0, 1, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {2, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {7, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {7, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {8, 0, 1, 0, 1}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {8, 0, 1, 0, 1});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {2, 0, 1, 0, 1}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {2, 0, 1, 0, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {6, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {6, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {3, 0, 0, 0, 4}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {3, 0, 0, 0, 4});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {1, 0, 0, 0, 2}, detailedLine3a.getCells());
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 2});
Row<DetailedMonitorQueryItem> detailedLine3b = line3.getFoldableRow("L99000");
assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine3b.getCells());
assertThat(detailedLine3b.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 1});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {4, 0, 2, 0, 4}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 4});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {4, 0, 2, 0, 4}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {4, 0, 2, 0, 4});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {6, 0, 0, 0, 7}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {6, 0, 0, 0, 7});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {6, 0, 0, 0, 7}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {6, 0, 0, 0, 7});
}
@WithAccessId(userName = "monitor")
@ -410,26 +411,26 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L30000");
assertArrayEquals(new int[] {2, 1, 0, 1, 3}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {2, 1, 0, 1, 3});
Row<DetailedMonitorQueryItem> detailedLine1a = line1.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 1, 0, 1, 1}, detailedLine1a.getCells());
assertThat(detailedLine1a.getCells()).isEqualTo(new int[] {0, 1, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLine1b = line1.getFoldableRow("L99000");
assertArrayEquals(new int[] {0, 0, 0, 0, 1}, detailedLine1b.getCells());
assertThat(detailedLine1b.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 1});
Row<DetailedMonitorQueryItem> detailedLine1WithoutAttachment = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 1}, detailedLine1WithoutAttachment.getCells());
assertThat(detailedLine1WithoutAttachment.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 1});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L40000");
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
Row<DetailedMonitorQueryItem> detailedLine2WithoutAttachment = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 2, 2, 0, 4}, detailedLine2WithoutAttachment.getCells());
assertThat(detailedLine2WithoutAttachment.getCells()).isEqualTo(new int[] {2, 2, 2, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -453,47 +454,47 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {5, 2, 1, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {5, 2, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {1, 0, 1, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {1, 0, 1, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {4, 2, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {4, 2, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {3, 1, 1, 1, 0}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {3, 1, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {1, 0, 1, 1, 0}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {1, 0, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 1, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {2, 1, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {1, 0, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLine3 = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 0, 0, 1, 1}, detailedLine3.getCells());
assertThat(detailedLine3.getCells()).isEqualTo(new int[] {0, 0, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {2, 0, 0, 0, 3}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 3});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {2, 0, 0, 0, 3}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {2, 0, 0, 0, 3});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {0, 1, 0, 3, 0}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {0, 1, 0, 3, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {0, 1, 0, 3, 0}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {0, 1, 0, 3, 0});
}
@WithAccessId(userName = "monitor")
@ -518,47 +519,47 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(5, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(5);
FoldableRow<DetailedMonitorQueryItem> line1 = report.getRow("L10000");
assertArrayEquals(new int[] {4, 0, 0, 0, 0}, line1.getCells());
assertThat(line1.getCells()).isEqualTo(new int[] {4, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLine1 = line1.getFoldableRow("L11000");
assertArrayEquals(new int[] {1, 0, 0, 0, 0}, detailedLine1.getCells());
assertThat(detailedLine1.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment1 = line1.getFoldableRow("N/A");
assertArrayEquals(new int[] {3, 0, 0, 0, 0}, detailedLineNoAttachment1.getCells());
assertThat(detailedLineNoAttachment1.getCells()).isEqualTo(new int[] {3, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line2 = report.getRow("L20000");
assertArrayEquals(new int[] {4, 1, 1, 1, 0}, line2.getCells());
assertThat(line2.getCells()).isEqualTo(new int[] {4, 1, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLine2 = line2.getFoldableRow("L22000");
assertArrayEquals(new int[] {1, 1, 1, 1, 0}, detailedLine2.getCells());
assertThat(detailedLine2.getCells()).isEqualTo(new int[] {1, 1, 1, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment2 = line2.getFoldableRow("N/A");
assertArrayEquals(new int[] {3, 0, 0, 0, 0}, detailedLineNoAttachment2.getCells());
assertThat(detailedLineNoAttachment2.getCells()).isEqualTo(new int[] {3, 0, 0, 0, 0});
FoldableRow<DetailedMonitorQueryItem> line3 = report.getRow("L30000");
assertArrayEquals(new int[] {1, 0, 0, 1, 1}, line3.getCells());
assertThat(line3.getCells()).isEqualTo(new int[] {1, 0, 0, 1, 1});
Row<DetailedMonitorQueryItem> detailedLine3a = line3.getFoldableRow("L33000");
assertArrayEquals(new int[] {0, 0, 0, 1, 0}, detailedLine3a.getCells());
assertThat(detailedLine3a.getCells()).isEqualTo(new int[] {0, 0, 0, 1, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment3 = line3.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 0, 0, 0, 1}, detailedLineNoAttachment3.getCells());
assertThat(detailedLineNoAttachment3.getCells()).isEqualTo(new int[] {1, 0, 0, 0, 1});
FoldableRow<DetailedMonitorQueryItem> line4 = report.getRow("L40000");
assertArrayEquals(new int[] {1, 1, 2, 0, 2}, line4.getCells());
assertThat(line4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 2});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment4 = line4.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 1, 2, 0, 2}, detailedLineNoAttachment4.getCells());
assertThat(detailedLineNoAttachment4.getCells()).isEqualTo(new int[] {1, 1, 2, 0, 2});
FoldableRow<DetailedMonitorQueryItem> line5 = report.getRow("L50000");
assertArrayEquals(new int[] {1, 2, 0, 2, 0}, line5.getCells());
assertThat(line5.getCells()).isEqualTo(new int[] {1, 2, 0, 2, 0});
Row<DetailedMonitorQueryItem> detailedLineNoAttachment5 = line5.getFoldableRow("N/A");
assertArrayEquals(new int[] {1, 2, 0, 2, 0}, detailedLineNoAttachment5.getCells());
assertThat(detailedLineNoAttachment5.getCells()).isEqualTo(new int[] {1, 2, 0, 2, 0});
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,14 +1,13 @@
package acceptance.report;
import static java.util.Arrays.asList;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -44,9 +43,11 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> monitorService.createTaskStatusReportBuilder().buildReport());
ThrowingCallable call =
() -> {
monitorService.createTaskStatusReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -60,24 +61,24 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
Row<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22, 4, 0, 0, 0}, row1.getCells());
assertEquals(26, row1.getTotalValue());
assertThat(row1.getCells()).isEqualTo(new int[] {22, 4, 0, 0, 0});
assertThat(row1.getTotalValue()).isEqualTo(26);
Row<TaskQueryItem> row2 = report.getRow("DOMAIN_B");
assertArrayEquals(new int[] {9, 3, 0, 0, 0}, row2.getCells());
assertEquals(12, row2.getTotalValue());
assertThat(row2.getCells()).isEqualTo(new int[] {9, 3, 0, 0, 0});
assertThat(row2.getTotalValue()).isEqualTo(12);
Row<TaskQueryItem> row3 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10, 2, 0, 0, 0}, row3.getCells());
assertEquals(12, row3.getTotalValue());
assertThat(row3.getCells()).isEqualTo(new int[] {10, 2, 0, 0, 0});
assertThat(row3.getTotalValue()).isEqualTo(12);
Row<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {41, 9, 0, 0, 0}, sumRow.getCells());
assertEquals(50, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {41, 9, 0, 0, 0});
assertThat(sumRow.getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "admin")
@ -104,20 +105,20 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(2, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(2);
Row<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22, 4, 0, 0, 0}, row1.getCells());
assertEquals(26, row1.getTotalValue());
assertThat(row1.getCells()).isEqualTo(new int[] {22, 4, 0, 0, 0});
assertThat(row1.getTotalValue()).isEqualTo(26);
Row<TaskQueryItem> row2 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10, 2, 0, 0, 0}, row2.getCells());
assertEquals(12, row2.getTotalValue());
assertThat(row2.getCells()).isEqualTo(new int[] {10, 2, 0, 0, 0});
assertThat(row2.getTotalValue()).isEqualTo(12);
Row<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {32, 6, 0, 0, 0}, sumRow.getCells());
assertEquals(38, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {32, 6, 0, 0, 0});
assertThat(sumRow.getTotalValue()).isEqualTo(38);
}
@WithAccessId(userName = "monitor")
@ -136,24 +137,24 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
Row<TaskQueryItem> row1 = report.getRow("DOMAIN_A");
assertArrayEquals(new int[] {22}, row1.getCells());
assertEquals(22, row1.getTotalValue());
assertThat(row1.getCells()).isEqualTo(new int[] {22});
assertThat(row1.getTotalValue()).isEqualTo(22);
Row<TaskQueryItem> row2 = report.getRow("DOMAIN_B");
assertArrayEquals(new int[] {9}, row2.getCells());
assertEquals(9, row2.getTotalValue());
assertThat(row2.getCells()).isEqualTo(new int[] {9});
assertThat(row2.getTotalValue()).isEqualTo(9);
Row<TaskQueryItem> row3 = report.getRow("DOMAIN_C");
assertArrayEquals(new int[] {10}, row3.getCells());
assertEquals(10, row3.getTotalValue());
assertThat(row3.getCells()).isEqualTo(new int[] {10});
assertThat(row3.getTotalValue()).isEqualTo(10);
Row<TaskQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {41}, sumRow.getCells());
assertEquals(41, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {41});
assertThat(sumRow.getTotalValue()).isEqualTo(41);
}
@WithAccessId(
@ -185,9 +186,9 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
// String rep = reportToString(report);
// System.out.println(rep);
int[] summaryNumbers = report.getSumRow().getCells();
assertEquals(5, summaryNumbers.length);
assertEquals(2, summaryNumbers[3]); // number of cancelled tasks
assertEquals(3, summaryNumbers[4]); // number of terminated tasks
assertThat(summaryNumbers.length).isEqualTo(5);
assertThat(summaryNumbers[3]).isEqualTo(2); // number of cancelled tasks
assertThat(summaryNumbers[4]).isEqualTo(3); // number of terminated tasks
}
private String reportToString(TaskStatusReport report) {

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

@ -1,7 +1,6 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Arrays;
import java.util.Collections;
@ -48,151 +47,153 @@ class ProvideTimestampReportAccTest extends AbstractReportAccTest {
final HashSet<String> org1Set = new HashSet<>(Arrays.asList("N/A", "org1"));
final HashSet<String> allOtherOrgLevelSet = new HashSet<>(Collections.singletonList("N/A"));
assertEquals(2, timestampReport.getRows().size());
assertEquals(
new HashSet<>(Arrays.asList("CREATED", "COMPLETED")), timestampReport.getRows().keySet());
assertThat(timestampReport.getRows()).hasSize(2);
assertThat(timestampReport.getRows().keySet())
.isEqualTo(new HashSet<>(Arrays.asList("CREATED", "COMPLETED")));
// * * * * * * * * * * * * * * * * * * * * * TEST THE CREATED ROW * * * * * * * * * * * * * *
// * * * * * * *
TimestampRow statusRow = timestampReport.getRow("CREATED");
assertEquals(2, statusRow.getFoldableRowCount());
assertEquals(org1Set, statusRow.getFoldableRowKeySet());
assertThat(statusRow.getFoldableRowCount()).isEqualTo(2);
assertThat(statusRow.getFoldableRowKeySet()).isEqualTo(org1Set);
// 2 Entries with -8 days and one with -9 days.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0}, statusRow.getCells());
assertEquals(3, statusRow.getTotalValue());
assertThat(statusRow.getCells())
.isEqualTo(new int[] {0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0});
assertThat(statusRow.getTotalValue()).isEqualTo(3);
// 'CREATED' -> 'org1'
TimestampRow.OrgLevel1Row org1Row = statusRow.getFoldableRow("org1");
assertEquals(1, org1Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org1Row.getFoldableRowKeySet());
assertThat(org1Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org1Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// only task TKI:000000000000000000000000000000000029 in 'org1'.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0}, org1Row.getCells());
assertEquals(1, org1Row.getTotalValue());
assertThat(org1Row.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0});
assertThat(org1Row.getTotalValue()).isEqualTo(1);
// 'CREATED' -> 'org1'/'N/A'
TimestampRow.OrgLevel2Row org2Row = org1Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org2Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org2Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org1Row.getCells(), org2Row.getCells());
assertEquals(org1Row.getTotalValue(), org2Row.getTotalValue());
assertThat(org2Row.getCells()).isEqualTo(org1Row.getCells());
assertThat(org2Row.getTotalValue()).isEqualTo(org1Row.getTotalValue());
// 'CREATED' -> 'org1'/'N/A'/'N/A'
TimestampRow.OrgLevel3Row org3Row = org2Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org3Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org3Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org2Row.getCells(), org3Row.getCells());
assertEquals(org2Row.getTotalValue(), org3Row.getTotalValue());
assertThat(org3Row.getCells()).isEqualTo(org2Row.getCells());
assertThat(org3Row.getTotalValue()).isEqualTo(org2Row.getTotalValue());
// 'CREATED' -> 'org1'/'N/A'/'N/A'/'N/A'
SingleRow<TimestampQueryItem> org4Row = org3Row.getFoldableRow("N/A");
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org3Row.getCells(), org4Row.getCells());
assertEquals(org3Row.getTotalValue(), org4Row.getTotalValue());
assertThat(org4Row.getCells()).isEqualTo(org3Row.getCells());
assertThat(org4Row.getTotalValue()).isEqualTo(org3Row.getTotalValue());
// 'CREATED' -> 'N/A'
org1Row = statusRow.getFoldableRow("N/A");
assertEquals(1, org1Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org1Row.getFoldableRowKeySet());
assertThat(org1Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org1Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// task TKI:000000000000000000000000000000000030,
// and TKI:000000000000000000000000000000000036 in 'N/A'.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0}, org1Row.getCells());
assertEquals(2, org1Row.getTotalValue());
assertThat(org1Row.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0});
assertThat(org1Row.getTotalValue()).isEqualTo(2);
// 'CREATED' -> 'N/A'/'N/A'
org2Row = org1Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org2Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org2Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org1Row.getCells(), org2Row.getCells());
assertEquals(org1Row.getTotalValue(), org2Row.getTotalValue());
assertThat(org2Row.getCells()).isEqualTo(org1Row.getCells());
assertThat(org2Row.getTotalValue()).isEqualTo(org1Row.getTotalValue());
// 'CREATED' -> 'N/A'/'N/A'/'N/A'
org3Row = org2Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org3Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org3Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org2Row.getCells(), org3Row.getCells());
assertEquals(org2Row.getTotalValue(), org3Row.getTotalValue());
assertThat(org3Row.getCells()).isEqualTo(org2Row.getCells());
assertThat(org3Row.getTotalValue()).isEqualTo(org2Row.getTotalValue());
// 'CREATED' -> 'N/A'/'N/A'/'N/A'/'N/A'
org4Row = org3Row.getFoldableRow("N/A");
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org3Row.getCells(), org4Row.getCells());
assertEquals(org3Row.getTotalValue(), org4Row.getTotalValue());
assertThat(org4Row.getCells()).isEqualTo(org3Row.getCells());
assertThat(org4Row.getTotalValue()).isEqualTo(org3Row.getTotalValue());
// * * * * * * * * * * * * * * * * * * * * * TEST THE COMPLETED ROW * * * * * * * * * * * * *
// * * * * * * * *
statusRow = timestampReport.getRow("COMPLETED");
assertEquals(2, statusRow.getFoldableRowCount());
assertEquals(org1Set, statusRow.getFoldableRowKeySet());
assertThat(statusRow.getFoldableRowCount()).isEqualTo(2);
assertThat(statusRow.getFoldableRowKeySet()).isEqualTo(org1Set);
// 2 Entries with -1 days, one with -2 days and one with -7 days.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 2}, statusRow.getCells());
assertEquals(4, statusRow.getTotalValue());
assertThat(statusRow.getCells())
.isEqualTo(new int[] {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 2});
assertThat(statusRow.getTotalValue()).isEqualTo(4);
// 'COMPLETED' -> 'org1'
org1Row = statusRow.getFoldableRow("org1");
assertEquals(1, org1Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org1Row.getFoldableRowKeySet());
assertThat(org1Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org1Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// only task TKI:000000000000000000000000000000000029 in 'org1'.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0}, org1Row.getCells());
assertEquals(1, org1Row.getTotalValue());
assertThat(org1Row.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0});
assertThat(org1Row.getTotalValue()).isEqualTo(1);
// 'COMPLETED' -> 'org1'/'N/A'
org2Row = org1Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org2Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org2Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org1Row.getCells(), org2Row.getCells());
assertEquals(org1Row.getTotalValue(), org2Row.getTotalValue());
assertThat(org2Row.getCells()).isEqualTo(org1Row.getCells());
assertThat(org2Row.getTotalValue()).isEqualTo(org1Row.getTotalValue());
// 'COMPLETED' -> 'org1'/'N/A'/'N/A'
org3Row = org2Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org3Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org3Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org2Row.getCells(), org3Row.getCells());
assertEquals(org2Row.getTotalValue(), org3Row.getTotalValue());
assertThat(org3Row.getCells()).isEqualTo(org2Row.getCells());
assertThat(org3Row.getTotalValue()).isEqualTo(org2Row.getTotalValue());
// 'COMPLETED' -> 'org1'/'N/A'/'N/A'/'N/A'
org4Row = org3Row.getFoldableRow("N/A");
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org3Row.getCells(), org4Row.getCells());
assertEquals(org3Row.getTotalValue(), org4Row.getTotalValue());
assertThat(org4Row.getCells()).isEqualTo(org3Row.getCells());
assertThat(org4Row.getTotalValue()).isEqualTo(org3Row.getTotalValue());
// 'COMPLETED' -> 'N/A'
org1Row = statusRow.getFoldableRow("N/A");
assertEquals(1, org1Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org1Row.getFoldableRowKeySet());
assertThat(org1Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org1Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// task TKI:000000000000000000000000000000000032,
// TKI:000000000000000000000000000000000034,
// and TKI:000000000000000000000000000000000037 in 'N/A'.
assertArrayEquals(new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2}, org1Row.getCells());
assertEquals(3, org1Row.getTotalValue());
assertThat(org1Row.getCells()).isEqualTo(new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2});
assertThat(org1Row.getTotalValue()).isEqualTo(3);
// 'COMPLETED' -> 'N/A'/'N/A'
org2Row = org1Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org2Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org2Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org1Row.getCells(), org2Row.getCells());
assertEquals(org1Row.getTotalValue(), org2Row.getTotalValue());
assertThat(org2Row.getCells()).isEqualTo(org1Row.getCells());
assertThat(org2Row.getTotalValue()).isEqualTo(org1Row.getTotalValue());
// 'COMPLETED' -> 'N/A'/'N/A'/'N/A'
org3Row = org2Row.getFoldableRow("N/A");
assertEquals(1, org2Row.getFoldableRowCount());
assertEquals(allOtherOrgLevelSet, org3Row.getFoldableRowKeySet());
assertThat(org2Row.getFoldableRowCount()).isEqualTo(1);
assertThat(org3Row.getFoldableRowKeySet()).isEqualTo(allOtherOrgLevelSet);
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org2Row.getCells(), org3Row.getCells());
assertEquals(org2Row.getTotalValue(), org3Row.getTotalValue());
assertThat(org3Row.getCells()).isEqualTo(org2Row.getCells());
assertThat(org3Row.getTotalValue()).isEqualTo(org2Row.getTotalValue());
// 'COMPLETED' -> 'N/A'/'N/A'/'N/A'/'N/A'
org4Row = org3Row.getFoldableRow("N/A");
// Since no further separation (in org level) they should be the same.
assertArrayEquals(org3Row.getCells(), org4Row.getCells());
assertEquals(org3Row.getTotalValue(), org4Row.getTotalValue());
assertThat(org4Row.getCells()).isEqualTo(org3Row.getCells());
assertThat(org4Row.getTotalValue()).isEqualTo(org3Row.getTotalValue());
}
}

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

@ -1,8 +1,7 @@
package acceptance.report;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.ArrayList;
import java.util.Arrays;
@ -11,7 +10,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
@ -38,10 +37,11 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> monitorService.createWorkbasketReportBuilder().buildReport());
ThrowingCallable call =
() -> {
monitorService.createWorkbasketReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "monitor")
@ -56,14 +56,14 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(20, report.getRow("USER_1_1").getTotalValue());
assertEquals(20, report.getRow("USER_1_2").getTotalValue());
assertEquals(10, report.getRow("USER_1_3").getTotalValue());
assertThat(report.getRow("USER_1_1").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_2").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_3").getTotalValue()).isEqualTo(10);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -87,18 +87,18 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
final int sumLineCount = IntStream.of(report.getSumRow().getCells()).sum();
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(20, report.getRow("USER_1_1").getTotalValue());
assertEquals(20, report.getRow("USER_1_2").getTotalValue());
assertEquals(10, report.getRow("USER_1_3").getTotalValue());
assertThat(report.getRow("USER_1_1").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_2").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_3").getTotalValue()).isEqualTo(10);
int[] sumRow = report.getSumRow().getCells();
assertArrayEquals(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5}, sumRow);
assertThat(sumRow).isEqualTo(new int[] {10, 9, 11, 0, 4, 0, 7, 4, 5});
assertEquals(50, report.getSumRow().getTotalValue());
assertEquals(50, sumLineCount);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
assertThat(sumLineCount).isEqualTo(50);
}
@WithAccessId(userName = "monitor")
@ -119,17 +119,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {13, 3, 1, 1, 2}, row1);
assertThat(row1).isEqualTo(new int[] {13, 3, 1, 1, 2});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {4, 6, 3, 6, 1}, row2);
assertThat(row2).isEqualTo(new int[] {4, 6, 3, 6, 1});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {2, 2, 0, 0, 6}, row3);
assertThat(row3).isEqualTo(new int[] {2, 2, 0, 0, 6});
}
@WithAccessId(userName = "monitor")
@ -150,17 +150,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {16, 0, 1, 0, 3}, row1);
assertThat(row1).isEqualTo(new int[] {16, 0, 1, 0, 3});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {10, 0, 3, 0, 7}, row2);
assertThat(row2).isEqualTo(new int[] {10, 0, 3, 0, 7});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {4, 0, 0, 0, 6}, row3);
assertThat(row3).isEqualTo(new int[] {4, 0, 0, 0, 6});
}
@WithAccessId(userName = "monitor")
@ -185,11 +185,11 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(1, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {13, 3, 1, 1, 2}, row1);
assertThat(row1).isEqualTo(new int[] {13, 3, 1, 1, 2});
}
@WithAccessId(userName = "monitor")
@ -213,17 +213,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {13, 3, 1, 1, 0}, row1);
assertThat(row1).isEqualTo(new int[] {13, 3, 1, 1, 0});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {4, 6, 3, 6, 0}, row2);
assertThat(row2).isEqualTo(new int[] {4, 6, 3, 6, 0});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {2, 2, 0, 0, 0}, row3);
assertThat(row3).isEqualTo(new int[] {2, 2, 0, 0, 0});
}
@WithAccessId(userName = "monitor")
@ -247,17 +247,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {3, 1, 1, 1, 2}, row1);
assertThat(row1).isEqualTo(new int[] {3, 1, 1, 1, 2});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {1, 1, 1, 0, 1}, row2);
assertThat(row2).isEqualTo(new int[] {1, 1, 1, 0, 1});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {0, 1, 0, 0, 4}, row3);
assertThat(row3).isEqualTo(new int[] {0, 1, 0, 0, 4});
}
@WithAccessId(userName = "monitor")
@ -281,17 +281,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {8, 1, 0, 1, 2}, row1);
assertThat(row1).isEqualTo(new int[] {8, 1, 0, 1, 2});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {2, 2, 2, 4, 0}, row2);
assertThat(row2).isEqualTo(new int[] {2, 2, 2, 4, 0});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {1, 1, 0, 0, 2}, row3);
assertThat(row3).isEqualTo(new int[] {1, 1, 0, 0, 2});
}
@WithAccessId(userName = "monitor")
@ -316,17 +316,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {6, 1, 1, 1, 1}, row1);
assertThat(row1).isEqualTo(new int[] {6, 1, 1, 1, 1});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {3, 2, 2, 3, 1}, row2);
assertThat(row2).isEqualTo(new int[] {3, 2, 2, 3, 1});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {2, 1, 0, 0, 1}, row3);
assertThat(row3).isEqualTo(new int[] {2, 1, 0, 0, 1});
}
@WithAccessId(userName = "monitor")
@ -364,17 +364,17 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report, columnHeaders));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
int[] row1 = report.getRow("USER_1_1").getCells();
assertArrayEquals(new int[] {3, 3, 0, 1, 1}, row1);
assertThat(row1).isEqualTo(new int[] {3, 3, 0, 1, 1});
int[] row2 = report.getRow("USER_1_2").getCells();
assertArrayEquals(new int[] {0, 2, 1, 6, 0}, row2);
assertThat(row2).isEqualTo(new int[] {0, 2, 1, 6, 0});
int[] row3 = report.getRow("USER_1_3").getCells();
assertArrayEquals(new int[] {1, 0, 0, 0, 3}, row3);
assertThat(row3).isEqualTo(new int[] {1, 0, 0, 0, 3});
}
@WithAccessId(userName = "monitor")
@ -394,16 +394,16 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
LOGGER.debug(reportToString(report));
}
assertNotNull(report);
assertEquals(3, report.rowSize());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(3);
assertEquals(20, report.getRow("USER_1_1").getTotalValue());
assertEquals(20, report.getRow("USER_1_2").getTotalValue());
assertEquals(10, report.getRow("USER_1_3").getTotalValue());
assertEquals(2, report.getRow("USER_1_1").getCells()[2]);
assertEquals(1, report.getRow("USER_1_2").getCells()[1]);
assertThat(report.getRow("USER_1_1").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_2").getTotalValue()).isEqualTo(20);
assertThat(report.getRow("USER_1_3").getTotalValue()).isEqualTo(10);
assertThat(report.getRow("USER_1_1").getCells()[2]).isEqualTo(2);
assertThat(report.getRow("USER_1_2").getCells()[1]).isEqualTo(1);
assertEquals(50, report.getSumRow().getTotalValue());
assertThat(report.getSumRow().getTotalValue()).isEqualTo(50);
}
private List<TimeIntervalColumnHeader> getListOfColumnHeaders() {

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

@ -1,7 +1,6 @@
package acceptance.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -31,8 +30,8 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertNotNull(classificationSummaryList);
assertEquals(17, classificationSummaryList.size());
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(17);
}
@WithAccessId(userName = "businessadmin")
@ -42,8 +41,8 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertNotNull(classificationSummaryList);
assertEquals(17, classificationSummaryList.size());
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(17);
}
@WithAccessId(userName = "admin")
@ -53,7 +52,7 @@ class ClassificationQueryAccTest extends AbstractAccTest {
List<ClassificationSummary> classificationSummaryList =
classificationService.createClassificationQuery().domainIn("DOMAIN_A").list();
assertNotNull(classificationSummaryList);
assertEquals(17, classificationSummaryList.size());
assertThat(classificationSummaryList).isNotNull();
assertThat(classificationSummaryList).hasSize(17);
}
}

46
lib/taskana-core/src/test/java/acceptance/security/TaskEngineAccTest.java
View File

@ -1,10 +1,10 @@
package acceptance.security;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -24,11 +24,13 @@ class TaskEngineAccTest extends AbstractAccTest {
@Test
void testUnauthenticated() {
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN));
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isFalse();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
ThrowingCallable call =
() -> {
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -36,27 +38,29 @@ class TaskEngineAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testRunAsAdminIsOnlyTemporary() throws NoSuchFieldException, IllegalAccessException {
assertTrue(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN));
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isTrue();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
new TaskanaEngineProxyForTest(taskanaEngine)
.getEngine()
.runAsAdmin(
() -> {
assertTrue(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isTrue();
return true;
});
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
}
@WithAccessId(userName = "user_1_1") // , groupNames = {"businessadmin"})
@Test
void testUser() throws NotAuthorizedException {
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN));
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isFalse();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
ThrowingCallable call =
() -> {
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -64,8 +68,8 @@ class TaskEngineAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testBusinessAdmin() throws NotAuthorizedException {
assertTrue(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN));
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isTrue();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN);
}
@ -74,8 +78,8 @@ class TaskEngineAccTest extends AbstractAccTest {
groupNames = {"admin"})
@Test
void testAdmin() throws NotAuthorizedException {
assertFalse(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN));
assertTrue(taskanaEngine.isUserInRole(TaskanaRole.ADMIN));
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isFalse();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isTrue();
taskanaEngine.checkRoleMembership(TaskanaRole.ADMIN);
}
}

11
lib/taskana-core/src/test/java/acceptance/security/TaskQueryAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.security;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -27,7 +26,7 @@ class TaskQueryAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery().ownerLike("%a%", "%u%").list();
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
}
@WithAccessId(userName = "user_1_1") // , groupNames = {"businessadmin"})
@ -37,7 +36,7 @@ class TaskQueryAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery().ownerLike("%a%", "%u%").list();
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -49,7 +48,7 @@ class TaskQueryAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery().ownerLike("%a%", "%u%").list();
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -61,6 +60,6 @@ class TaskQueryAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery().ownerLike("%a%", "%u%").list();
assertThat(results.size(), equalTo(35));
assertThat(results).hasSize(35);
}
}

56
lib/taskana-core/src/test/java/acceptance/security/WorkbasketQueryAccTest.java
View File

@ -1,10 +1,11 @@
package acceptance.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -29,16 +30,17 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();
assertEquals(0L, results.size());
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService
.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list());
assertThat(results).isEmpty();
ThrowingCallable call =
() -> {
workbasketService
.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "unknown")
@ -47,17 +49,17 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();
assertEquals(0L, results.size());
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService
.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list());
assertThat(results).isEmpty();
ThrowingCallable call =
() -> {
workbasketService
.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "unknown", groupNames = "businessadmin")
@ -67,7 +69,7 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();
assertEquals(25L, results.size());
assertThat(results).hasSize(25);
results =
workbasketService
@ -77,7 +79,7 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
assertEquals(13L, results.size());
assertThat(results).hasSize(13);
}
@WithAccessId(userName = "unknown", groupNames = "admin")
@ -86,7 +88,7 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();
assertEquals(25L, results.size());
assertThat(results).hasSize(25);
results =
workbasketService
@ -96,6 +98,6 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
assertEquals(13L, results.size());
assertThat(results).hasSize(13);
}
}

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

@ -1,8 +1,7 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
@ -11,7 +10,7 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -49,19 +48,21 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask = createTask(taskService, CallbackState.NONE);
createdTask = (TaskImpl) taskService.getTask(createdTask.getId());
assertEquals(CallbackState.NONE, createdTask.getCallbackState());
assertThat(createdTask.getCallbackState()).isEqualTo(CallbackState.NONE);
createdTask = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
createdTask = (TaskImpl) taskService.getTask(createdTask.getId());
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask.getCallbackState());
assertThat(createdTask.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
createdTask = createTask(taskService, CallbackState.CALLBACK_PROCESSING_COMPLETED);
createdTask = (TaskImpl) taskService.getTask(createdTask.getId());
assertEquals(CallbackState.CALLBACK_PROCESSING_COMPLETED, createdTask.getCallbackState());
assertThat(createdTask.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
createdTask = createTask(taskService, CallbackState.CLAIMED);
createdTask = (TaskImpl) taskService.getTask(createdTask.getId());
assertEquals(CallbackState.CLAIMED, createdTask.getCallbackState());
assertThat(createdTask.getCallbackState()).isEqualTo(CallbackState.CLAIMED);
}
@WithAccessId(
@ -76,31 +77,41 @@ class CallbackStateAccTest extends AbstractAccTest {
final TaskImpl createdTask =
createTask(taskanaEngine.getTaskService(), CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask.getCallbackState());
assertThat(createdTask.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(TaskState.READY, createdTask.getState());
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
String endOfMessage = " cannot be deleted because its callback is not yet processed";
Throwable t =
Assertions.assertThrows(
InvalidStateException.class, () -> taskService.forceDeleteTask(createdTask.getId()));
assertTrue(t.getMessage().endsWith(endOfMessage));
ThrowingCallable call =
() -> {
taskService.forceDeleteTask(createdTask.getId());
};
assertThatThrownBy(call)
.isInstanceOf(InvalidStateException.class)
.hasMessageEndingWith(endOfMessage);
final TaskImpl createdTask2 = (TaskImpl) taskService.claim(createdTask.getId());
assertEquals(TaskState.CLAIMED, createdTask2.getState());
assertThat(createdTask2.getState()).isEqualTo(TaskState.CLAIMED);
Throwable t2 =
Assertions.assertThrows(
InvalidStateException.class, () -> taskService.forceDeleteTask(createdTask2.getId()));
assertTrue(t2.getMessage().endsWith(endOfMessage));
call =
() -> {
taskService.forceDeleteTask(createdTask2.getId());
};
assertThatThrownBy(call)
.isInstanceOf(InvalidStateException.class)
.hasMessageEndingWith(endOfMessage);
final TaskImpl createdTask3 = (TaskImpl) taskService.completeTask(createdTask.getId());
Throwable t3 =
Assertions.assertThrows(
InvalidStateException.class, () -> taskService.forceDeleteTask(createdTask3.getId()));
assertTrue(t3.getMessage().endsWith(endOfMessage));
call =
() -> {
taskService.forceDeleteTask(createdTask3.getId());
};
assertThatThrownBy(call)
.isInstanceOf(InvalidStateException.class)
.hasMessageEndingWith(endOfMessage);
}
@WithAccessId(
@ -114,24 +125,27 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskImpl createdTask1 =
createTask(taskanaEngine.getTaskService(), CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask1.getCallbackState());
assertThat(createdTask1.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask2 =
createTask(taskanaEngine.getTaskService(), CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask2.getCallbackState());
assertThat(createdTask2.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask3 =
createTask(taskanaEngine.getTaskService(), CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask3.getCallbackState());
assertThat(createdTask3.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskService taskService = taskanaEngine.getTaskService();
createdTask1 = (TaskImpl) taskService.forceCompleteTask(createdTask1.getId());
createdTask2 = (TaskImpl) taskService.forceCompleteTask(createdTask2.getId());
createdTask3 = (TaskImpl) taskService.forceCompleteTask(createdTask3.getId());
assertEquals(TaskState.COMPLETED, createdTask1.getState());
assertEquals(TaskState.COMPLETED, createdTask2.getState());
assertEquals(TaskState.COMPLETED, createdTask3.getState());
assertThat(createdTask1.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(createdTask2.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(createdTask3.getState()).isEqualTo(TaskState.COMPLETED);
List<String> taskIds =
new ArrayList<>(
@ -139,14 +153,13 @@ class CallbackStateAccTest extends AbstractAccTest {
// delete should fail because callback_state = CALLBACK_PROCESSING_REQUIRED
BulkOperationResults<String, TaskanaException> bulkResult1 = taskService.deleteTasks(taskIds);
assertTrue(bulkResult1.containsErrors());
assertThat(bulkResult1.containsErrors()).isTrue();
List<String> failedTaskIds = bulkResult1.getFailedIds();
assertEquals(3, failedTaskIds.size());
assertThat(failedTaskIds).hasSize(3);
for (String taskId : failedTaskIds) {
TaskanaException excpt = bulkResult1.getErrorForId(taskId);
assertEquals(
"pro.taskana.task.api.exceptions.InvalidStateException", excpt.getClass().getName());
assertThat(excpt.getClass().getName()).isEqualTo(InvalidStateException.class.getName());
}
List<String> externalIds =
new ArrayList<>(
@ -159,14 +172,14 @@ class CallbackStateAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> bulkResult2 =
taskService.setCallbackStateForTasks(
externalIds, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertFalse(bulkResult2.containsErrors());
assertThat(bulkResult2.containsErrors()).isFalse();
taskIds =
new ArrayList<>(
Arrays.asList(createdTask1.getId(), createdTask2.getId(), createdTask3.getId()));
// now it should be possible to delete the tasks
BulkOperationResults<String, TaskanaException> bulkResult3 = taskService.deleteTasks(taskIds);
assertFalse(bulkResult3.containsErrors());
assertThat(bulkResult3.containsErrors()).isFalse();
}
@WithAccessId(
@ -180,13 +193,15 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask1 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask1.getCallbackState());
assertThat(createdTask1.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask2 = createTask(taskService, CallbackState.CLAIMED);
assertEquals(CallbackState.CLAIMED, createdTask2.getCallbackState());
assertThat(createdTask2.getCallbackState()).isEqualTo(CallbackState.CLAIMED);
TaskImpl createdTask3 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertEquals(CallbackState.CALLBACK_PROCESSING_COMPLETED, createdTask3.getCallbackState());
assertThat(createdTask3.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
@ -200,9 +215,9 @@ class CallbackStateAccTest extends AbstractAccTest {
taskService.setCallbackStateForTasks(externalIds, CallbackState.NONE);
// It's never allowed to set CallbackState to NONE over public API
assertTrue(bulkResult.containsErrors());
assertThat(bulkResult.containsErrors()).isTrue();
List<String> failedTaskIds = bulkResult.getFailedIds();
assertTrue(failedTaskIds.size() == 3);
assertThat(failedTaskIds).hasSize(3);
}
@WithAccessId(
@ -217,13 +232,15 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask1 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask1.getCallbackState());
assertThat(createdTask1.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask2 = createTask(taskService, CallbackState.CLAIMED);
assertEquals(CallbackState.CLAIMED, createdTask2.getCallbackState());
assertThat(createdTask2.getCallbackState()).isEqualTo(CallbackState.CLAIMED);
TaskImpl createdTask3 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertEquals(CallbackState.CALLBACK_PROCESSING_COMPLETED, createdTask3.getCallbackState());
assertThat(createdTask3.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
@ -240,9 +257,9 @@ class CallbackStateAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> bulkResult =
taskService.setCallbackStateForTasks(
externalIds, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertTrue(bulkResult.containsErrors());
assertThat(bulkResult.containsErrors()).isTrue();
List<String> failedTaskIds = bulkResult.getFailedIds();
assertTrue(failedTaskIds.size() == 2 && !failedTaskIds.contains(createdTask3.getExternalId()));
assertThat(failedTaskIds).hasSize(2).doesNotContain(createdTask3.getExternalId());
}
@WithAccessId(
@ -257,13 +274,15 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask1 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask1.getCallbackState());
assertThat(createdTask1.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask2 = createTask(taskService, CallbackState.CLAIMED);
assertEquals(CallbackState.CLAIMED, createdTask2.getCallbackState());
assertThat(createdTask2.getCallbackState()).isEqualTo(CallbackState.CLAIMED);
TaskImpl createdTask3 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertEquals(CallbackState.CALLBACK_PROCESSING_COMPLETED, createdTask3.getCallbackState());
assertThat(createdTask3.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
@ -281,9 +300,12 @@ class CallbackStateAccTest extends AbstractAccTest {
// Therefore 2 tasks should not get updated
BulkOperationResults<String, TaskanaException> bulkResult =
taskService.setCallbackStateForTasks(externalIds, CallbackState.CLAIMED);
assertTrue(bulkResult.containsErrors());
assertThat(bulkResult.containsErrors()).isTrue();
List<String> failedTaskIds = bulkResult.getFailedIds();
assertTrue(failedTaskIds.size() == 2 && !failedTaskIds.contains(createdTask1.getExternalId()));
assertThat(failedTaskIds)
.hasSize(2)
.doesNotContain(createdTask1.getExternalId())
.containsOnly(createdTask2.getExternalId(), createdTask3.getExternalId());
}
@WithAccessId(
@ -297,13 +319,15 @@ class CallbackStateAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask1 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertEquals(CallbackState.CALLBACK_PROCESSING_REQUIRED, createdTask1.getCallbackState());
assertThat(createdTask1.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
TaskImpl createdTask2 = createTask(taskService, CallbackState.CLAIMED);
assertEquals(CallbackState.CLAIMED, createdTask2.getCallbackState());
assertThat(createdTask2.getCallbackState()).isEqualTo(CallbackState.CLAIMED);
TaskImpl createdTask3 = createTask(taskService, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertEquals(CallbackState.CALLBACK_PROCESSING_COMPLETED, createdTask3.getCallbackState());
assertThat(createdTask3.getCallbackState())
.isEqualTo(CallbackState.CALLBACK_PROCESSING_COMPLETED);
List<String> externalIds =
new ArrayList<>(
@ -318,9 +342,9 @@ class CallbackStateAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> bulkResult =
taskService.setCallbackStateForTasks(
externalIds, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertTrue(bulkResult.containsErrors());
assertThat(bulkResult.containsErrors()).isTrue();
List<String> failedTaskIds = bulkResult.getFailedIds();
assertTrue(failedTaskIds.size() == 1 && failedTaskIds.contains(createdTask3.getExternalId()));
assertThat(failedTaskIds).containsOnly(createdTask3.getExternalId());
}
@WithAccessId(
@ -333,7 +357,7 @@ class CallbackStateAccTest extends AbstractAccTest {
List<TaskSummary> claimedTasks =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();
assertTrue(claimedTasks.size() > 10);
assertThat(claimedTasks).hasSizeGreaterThan(10);
taskService.forceCompleteTask(claimedTasks.get(0).getId());
taskService.forceCompleteTask(claimedTasks.get(1).getId());
taskService.forceCompleteTask(claimedTasks.get(2).getId());
@ -347,14 +371,14 @@ class CallbackStateAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> bulkResultCompleted =
taskService.setCallbackStateForTasks(
externalIds, CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertFalse(bulkResultCompleted.containsErrors());
assertThat(bulkResultCompleted.containsErrors()).isFalse();
// now complete some additional tasks
taskService.forceCompleteTask(claimedTasks.get(3).getId());
taskService.forceCompleteTask(claimedTasks.get(4).getId());
taskService.forceCompleteTask(claimedTasks.get(5).getId());
long numberOfCompletedTasksAtStartOfTest = completedTasks.size();
int numberOfCompletedTasksAtStartOfTest = completedTasks.size();
// now lets retrieve those completed tasks that have callback_processing_required
List<TaskSummary> tasksToBeActedUpon =
taskService
@ -362,14 +386,14 @@ class CallbackStateAccTest extends AbstractAccTest {
.stateIn(TaskState.COMPLETED)
.callbackStateIn(CallbackState.CALLBACK_PROCESSING_REQUIRED)
.list();
assertEquals(tasksToBeActedUpon.size(), numberOfCompletedTasksAtStartOfTest);
assertThat(tasksToBeActedUpon).hasSize(numberOfCompletedTasksAtStartOfTest);
// now we set callback state to callback_processing_completed
externalIds =
tasksToBeActedUpon.stream().map(TaskSummary::getExternalId).collect(Collectors.toList());
BulkOperationResults<String, TaskanaException> bulkResult =
taskService.setCallbackStateForTasks(
externalIds, CallbackState.CALLBACK_PROCESSING_COMPLETED);
assertFalse(bulkResult.containsErrors());
assertThat(bulkResult.containsErrors()).isFalse();
long numOfTasksRemaining =
taskService
@ -377,7 +401,7 @@ class CallbackStateAccTest extends AbstractAccTest {
.stateIn(TaskState.COMPLETED)
.callbackStateIn(CallbackState.CALLBACK_PROCESSING_REQUIRED)
.count();
assertEquals(0, numOfTasksRemaining);
assertThat(numOfTasksRemaining).isEqualTo(0);
}
private TaskImpl createTask(TaskService taskService, CallbackState callbackState)

36
lib/taskana-core/src/test/java/acceptance/task/CancelTaskAccTest.java
View File

@ -41,7 +41,7 @@ class CancelTaskAccTest extends AbstractAccTest {
void testQeryCancelledTasks() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CANCELLED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
assertThat(taskSummaries).hasSize(5);
}
@WithAccessId(
@ -51,7 +51,7 @@ class CancelTaskAccTest extends AbstractAccTest {
void testCancelReadyTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
List<TaskSummary> taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list();
assertThat(taskSummaries.size()).isEqualTo(47);
assertThat(taskSummaries).hasSize(47);
taskService.cancelTask(taskSummaries.get(0).getId());
long numTasks = taskService.createTaskQuery().stateIn(TaskState.READY).count();
assertThat(numTasks).isEqualTo(46);
@ -67,7 +67,7 @@ class CancelTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();
assertThat(taskSummaries.size()).isEqualTo(16);
assertThat(taskSummaries).hasSize(16);
long numTasksCancelled = taskService.createTaskQuery().stateIn(TaskState.CANCELLED).count();
assertThat(numTasksCancelled).isEqualTo(5);
@ -83,16 +83,12 @@ class CancelTaskAccTest extends AbstractAccTest {
userName = "admin",
groupNames = {"group_1"})
@Test
void testCancelCompletedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testCancelCompletedTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.COMPLETED).list();
assertThat(taskSummaries.size()).isEqualTo(7);
assertThat(taskSummaries).hasSize(7);
ThrowingCallable taskanaCall =
() -> {
taskService.cancelTask(taskSummaries.get(0).getId());
};
ThrowingCallable taskanaCall = () -> taskService.cancelTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
@ -101,15 +97,11 @@ class CancelTaskAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testCancelTerminatedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testCancelTerminatedTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.TERMINATED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
ThrowingCallable taskanaCall =
() -> {
taskService.cancelTask(taskSummaries.get(0).getId());
};
assertThat(taskSummaries).hasSize(5);
ThrowingCallable taskanaCall = () -> taskService.cancelTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
@ -118,15 +110,11 @@ class CancelTaskAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testCancelCancelledTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testCancelCancelledTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CANCELLED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
ThrowingCallable taskanaCall =
() -> {
taskService.cancelTask(taskSummaries.get(0).getId());
};
assertThat(taskSummaries).hasSize(5);
ThrowingCallable taskanaCall = () -> taskService.cancelTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
}

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

@ -1,14 +1,11 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Instant;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -45,15 +42,13 @@ class CompleteTaskAccTest extends AbstractAccTest {
NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService();
assertEquals(
TaskState.CLAIMED,
taskService.getTask("TKI:000000000000000000000000000000000001").getState());
assertThat(taskService.getTask("TKI:000000000000000000000000000000000001").getState())
.isEqualTo(TaskState.CLAIMED);
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000001");
assertNotNull(completedTask);
assertNotNull(completedTask.getCompleted());
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotEquals(completedTask.getCreated(), completedTask.getModified());
assertThat(completedTask).isNotNull();
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getModified()).isNotEqualTo(completedTask.getCreated());
}
@WithAccessId(
@ -66,7 +61,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task completedTask = taskService.completeTask("TKI:000000000000000000000000000000000002");
Task completedTask2 = taskService.completeTask("TKI:000000000000000000000000000000000002");
assertEquals(completedTask, completedTask2);
assertThat(completedTask2).isEqualTo(completedTask);
}
@WithAccessId(
@ -91,10 +86,10 @@ class CompleteTaskAccTest extends AbstractAccTest {
Task createdTask = taskService.createTask(newTaskImpl);
Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted());
assertTrue(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified()));
assertEquals(completedTask.getModified(), completedTask.getCompleted());
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified())).isTrue();
assertThat(completedTask.getCompleted()).isEqualTo(completedTask.getModified());
}
@WithAccessId(
@ -118,10 +113,10 @@ class CompleteTaskAccTest extends AbstractAccTest {
Task createdTask = taskService.createTask(newTaskImpl);
Task completedTask = taskService.forceCompleteTask(createdTask.getId());
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted());
assertTrue(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified()));
assertEquals(completedTask.getModified(), completedTask.getCompleted());
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(isBeforeOrEqual(completedTask.getCreated(), completedTask.getModified())).isTrue();
assertThat(completedTask.getCompleted()).isEqualTo(completedTask.getModified());
}
@WithAccessId(
@ -131,21 +126,29 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testCompleteTaskThrowsErrors() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.completeTask("TKI:0000000000000000000000000000000000xx"));
ThrowingCallable call =
() -> {
taskService.completeTask("TKI:0000000000000000000000000000000000xx");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskService.completeTask("TKI:000000000000000000000000000000000004"));
call =
() -> {
taskService.completeTask("TKI:000000000000000000000000000000000004");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
Assertions.assertThrows(
InvalidStateException.class,
() -> taskService.completeTask("TKI:000000000000000000000000000000000025"));
call =
() -> {
taskService.completeTask("TKI:000000000000000000000000000000000025");
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
Assertions.assertThrows(
InvalidOwnerException.class,
() -> taskService.completeTask("TKI:000000000000000000000000000000000027"));
call =
() -> {
taskService.completeTask("TKI:000000000000000000000000000000000027");
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -165,19 +168,19 @@ class CompleteTaskAccTest extends AbstractAccTest {
newTask.setOwner(null);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertNull(createdTask.getClaimed());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
final Instant before = createdTask.getCreated();
Task claimedTask = taskService.claim(createdTask.getId());
assertNotNull(claimedTask.getOwner());
assertEquals(claimedTask.getOwner(), CurrentUserContext.getUserid());
assertNotNull(claimedTask.getClaimed());
assertTrue(isBeforeOrEqual(before, claimedTask.getClaimed()));
assertTrue(isBeforeOrEqual(claimedTask.getCreated(), claimedTask.getClaimed()));
assertTrue(isBeforeOrEqual(claimedTask.getClaimed(), Instant.now()));
assertEquals(claimedTask.getClaimed(), claimedTask.getModified());
assertThat(claimedTask.getOwner()).isNotNull();
assertThat(CurrentUserContext.getUserid()).isEqualTo(claimedTask.getOwner());
assertThat(claimedTask.getClaimed()).isNotNull();
assertThat(isBeforeOrEqual(before, claimedTask.getClaimed())).isTrue();
assertThat(isBeforeOrEqual(claimedTask.getCreated(), claimedTask.getClaimed())).isTrue();
assertThat(isBeforeOrEqual(claimedTask.getClaimed(), Instant.now())).isTrue();
assertThat(claimedTask.getModified()).isEqualTo(claimedTask.getClaimed());
}
@WithAccessId(
@ -197,19 +200,19 @@ class CompleteTaskAccTest extends AbstractAccTest {
newTask.setOwner("other_user");
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertEquals(createdTask.getOwner(), "other_user");
assertThat(createdTask).isNotNull();
assertThat("other_user").isEqualTo(createdTask.getOwner());
Instant beforeForceClaim = Instant.now();
Task taskAfterClaim = taskService.forceClaim(createdTask.getId());
assertEquals(CurrentUserContext.getUserid(), taskAfterClaim.getOwner());
assertTrue(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getModified()));
assertTrue(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getClaimed()));
assertTrue(isBeforeOrEqual(taskAfterClaim.getCreated(), taskAfterClaim.getModified()));
assertThat(taskAfterClaim.getOwner()).isEqualTo(CurrentUserContext.getUserid());
assertThat(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getModified())).isTrue();
assertThat(isBeforeOrEqual(beforeForceClaim, taskAfterClaim.getClaimed())).isTrue();
assertThat(isBeforeOrEqual(taskAfterClaim.getCreated(), taskAfterClaim.getModified())).isTrue();
assertEquals(TaskState.CLAIMED, taskAfterClaim.getState());
assertTrue(taskAfterClaim.isRead());
assertThat(taskAfterClaim.getState()).isEqualTo(TaskState.CLAIMED);
assertThat(taskAfterClaim.isRead()).isTrue();
}
@WithAccessId(
@ -219,7 +222,11 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testClaimTaskNotExisting() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(TaskNotFoundException.class, () -> taskService.claim("NOT_EXISTING"));
ThrowingCallable call =
() -> {
taskService.claim("NOT_EXISTING");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -229,9 +236,11 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testClaimTaskWithInvalidState() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
InvalidStateException.class,
() -> taskService.forceClaim("TKI:000000000000000000000000000000000036"));
ThrowingCallable call =
() -> {
taskService.forceClaim("TKI:000000000000000000000000000000000036");
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(
@ -241,9 +250,11 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testClaimTaskWithInvalidOwner() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
InvalidOwnerException.class,
() -> taskService.claim("TKI:000000000000000000000000000000000100"));
ThrowingCallable call =
() -> {
taskService.claim("TKI:000000000000000000000000000000000100");
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -253,9 +264,11 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testCancelClaimForcedWithInvalidState() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
InvalidStateException.class,
() -> taskService.forceCancelClaim("TKI:000000000000000000000000000000000036"));
ThrowingCallable call =
() -> {
taskService.forceCancelClaim("TKI:000000000000000000000000000000000036");
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(
@ -274,13 +287,13 @@ class CompleteTaskAccTest extends AbstractAccTest {
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertEquals(createdTask.getState(), TaskState.READY);
assertThat(createdTask).isNotNull();
assertThat(TaskState.READY).isEqualTo(createdTask.getState());
createdTask = taskService.cancelClaim(createdTask.getId());
assertNotNull(createdTask);
assertEquals(createdTask.getState(), TaskState.READY);
assertThat(createdTask).isNotNull();
assertThat(TaskState.READY).isEqualTo(createdTask.getState());
}
@WithAccessId(
@ -294,19 +307,19 @@ class CompleteTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task taskBefore = taskService.getTask("TKI:000000000000000000000000000000000043");
assertNotNull(taskBefore);
assertEquals(TaskState.CLAIMED, taskBefore.getState());
assertThat(taskBefore).isNotNull();
assertThat(taskBefore.getState()).isEqualTo(TaskState.CLAIMED);
final Instant before = Instant.now();
Thread.sleep(1);
Task taskAfter = taskService.forceCancelClaim("TKI:000000000000000000000000000000000043");
assertNotNull(taskAfter);
assertEquals(TaskState.READY, taskAfter.getState());
assertNull(taskAfter.getClaimed());
assertTrue(taskAfter.getModified().isAfter(before));
assertNull(taskAfter.getOwner());
assertTrue(taskAfter.isRead());
assertThat(taskAfter).isNotNull();
assertThat(taskAfter.getState()).isEqualTo(TaskState.READY);
assertThat(taskAfter.getClaimed()).isNull();
assertThat(taskAfter.getModified().isAfter(before)).isTrue();
assertThat(taskAfter.getOwner()).isNull();
assertThat(taskAfter.isRead()).isTrue();
}
@WithAccessId(
@ -316,9 +329,11 @@ class CompleteTaskAccTest extends AbstractAccTest {
void testCancelClaimWithInvalidOwner() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
InvalidOwnerException.class,
() -> taskService.cancelClaim("TKI:000000000000000000000000000000000100"));
ThrowingCallable call =
() -> {
taskService.cancelClaim("TKI:000000000000000000000000000000000100");
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
private boolean isBeforeOrEqual(Instant before, Instant after) {

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

@ -1,14 +1,8 @@
package acceptance.task;
import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
@ -19,7 +13,8 @@ import java.util.Map;
import java.util.function.Consumer;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.assertj.core.data.TemporalUnitWithinOffset;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -50,6 +45,8 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketInUseException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
// import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
class CreateTaskAccTest extends AbstractAccTest {
@ -73,9 +70,9 @@ class CreateTaskAccTest extends AbstractAccTest {
Task newTask = oldTask.copy();
newTask = taskService.createTask(newTask);
assertNotNull(newTask.getId());
assertNotEquals(newTask.getId(), oldTask.getId());
org.assertj.core.api.Assertions.assertThat(newTask.getAttachments())
assertThat(newTask.getId()).isNotNull();
assertThat(newTask.getId()).isNotEqualTo(oldTask.getId());
assertThat(newTask.getAttachments())
.extracting(AttachmentSummary::getTaskId)
.containsOnly(newTask.getId());
}
@ -96,24 +93,24 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setOwner("user_1_1");
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertThat(createdTask.getOwner(), equalTo("user_1_1"));
assertEquals("USER_1_1", createdTask.getWorkbasketKey());
assertEquals("T-Vertragstermin VERA", createdTask.getName());
assertEquals(objectReference, createdTask.getPrimaryObjRef());
assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId());
assertNull(createdTask.getClaimed());
assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState());
assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority());
assertFalse(createdTask.isRead());
assertFalse(createdTask.isTransferred());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(createdTask.getOwner()).isEqualTo("user_1_1");
assertThat(createdTask.getWorkbasketKey()).isEqualTo("USER_1_1");
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
assertThat(createdTask.getPrimaryObjRef()).isEqualTo(objectReference);
assertThat(createdTask.getCreated()).isNotNull();
assertThat(createdTask.getModified()).isNotNull();
assertThat(createdTask.getBusinessProcessId()).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
assertThat(createdTask.isRead()).isFalse();
assertThat(createdTask.isTransferred()).isFalse();
}
@WithAccessId(
@ -133,19 +130,14 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPlanned(instantPlanned);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getPlanned());
assertEquals(instantPlanned, createdTask.getPlanned());
assertTrue(createdTask.getCreated().isBefore(createdTask.getPlanned()));
assertThat(createdTask).isNotNull();
assertThat(createdTask.getPlanned()).isEqualTo(instantPlanned);
assertThat(createdTask.getCreated()).isBefore(createdTask.getPlanned());
// verify that planned takes place 2 hours after creation (+- 5 seconds)
Instant plannedAdjusted = createdTask.getPlanned().minus(2, ChronoUnit.HOURS);
long difference =
Duration.between(createdTask.getCreated(), plannedAdjusted).abs().getSeconds();
// add some tolerance to ignore that "created" depends on execution speed
long tolerance = 5;
assertTrue(Math.abs(difference) < tolerance);
assertThat(plannedAdjusted)
.isCloseTo(createdTask.getCreated(), new TemporalUnitWithinOffset(5L, ChronoUnit.SECONDS));
}
@WithAccessId(
@ -163,7 +155,11 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPlanned(instantPlanned);
newTask.setDue(instantPlanned); // due date not according to service level
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.createTask(newTask));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(
@ -193,7 +189,11 @@ class CreateTaskAccTest extends AbstractAccTest {
Instant shouldBeDueDate = newTask.getPlanned().plus(Duration.ofDays(calendarDays));
newTask.setDue(shouldBeDueDate);
Assertions.assertDoesNotThrow(() -> taskService.createTask(newTask));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatCode(call).doesNotThrowAnyException();
}
@WithAccessId(
@ -211,23 +211,23 @@ class CreateTaskAccTest extends AbstractAccTest {
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertEquals("T-Vertragstermin VERA", createdTask.getName());
assertEquals("1234567", createdTask.getPrimaryObjRef().getValue());
assertNotNull(createdTask.getExternalId());
assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId());
assertNull(createdTask.getClaimed());
assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState());
assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority());
assertFalse(createdTask.isRead());
assertFalse(createdTask.isTransferred());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
assertThat(createdTask.getExternalId()).isNotNull();
assertThat(createdTask.getCreated()).isNotNull();
assertThat(createdTask.getModified()).isNotNull();
assertThat(createdTask.getBusinessProcessId()).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
assertThat(createdTask.isRead()).isFalse();
assertThat(createdTask.isTransferred()).isFalse();
Task newTask2 = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask2.setExternalId("MyExternalId");
@ -235,8 +235,11 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask2.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Assertions.assertThrows(
TaskAlreadyExistException.class, () -> taskService.createTask(newTask2));
ThrowingCallable call =
() -> {
taskService.createTask(newTask2);
};
assertThatThrownBy(call).isInstanceOf(TaskAlreadyExistException.class);
}
@WithAccessId(
@ -256,21 +259,21 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setCustomAttributes(customAttributesForCreate);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertEquals("T-Vertragstermin VERA", createdTask.getName());
assertEquals("1234567", createdTask.getPrimaryObjRef().getValue());
assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId());
assertNull(createdTask.getClaimed());
assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState());
assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority());
assertFalse(createdTask.isRead());
assertFalse(createdTask.isTransferred());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
assertThat(createdTask.getCreated()).isNotNull();
assertThat(createdTask.getModified()).isNotNull();
assertThat(createdTask.getBusinessProcessId()).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
assertThat(createdTask.isRead()).isFalse();
assertThat(createdTask.isTransferred()).isFalse();
// verify that the database content is as expected
TaskanaEngineProxyForTest engineProxy = new TaskanaEngineProxyForTest(taskanaEngine);
try {
@ -283,27 +286,29 @@ class CreateTaskAccTest extends AbstractAccTest {
engineProxy.openConnection();
String customProperties = mapper.getCustomAttributesAsString(createdTask.getId());
assertTrue(customProperties.contains("\"Property_13\":\"Property Value of Property_13\""));
assertTrue(customProperties.contains("\"Property_12\":\"Property Value of Property_12\""));
assertTrue(customProperties.contains("\"Property_11\":\"Property Value of Property_11\""));
assertTrue(customProperties.contains("\"Property_10\":\"Property Value of Property_10\""));
assertTrue(customProperties.contains("\"Property_9\":\"Property Value of Property_9\""));
assertTrue(customProperties.contains("\"Property_8\":\"Property Value of Property_8\""));
assertTrue(customProperties.contains("\"Property_7\":\"Property Value of Property_7\""));
assertTrue(customProperties.contains("\"Property_6\":\"Property Value of Property_6\""));
assertTrue(customProperties.contains("\"Property_5\":\"Property Value of Property_5\""));
assertTrue(customProperties.contains("\"Property_4\":\"Property Value of Property_4\""));
assertTrue(customProperties.contains("\"Property_3\":\"Property Value of Property_3\""));
assertTrue(customProperties.contains("\"Property_2\":\"Property Value of Property_2\""));
assertTrue(customProperties.contains("\"Property_1\":\"Property Value of Property_1\""));
assertThat(customProperties)
.contains(
"\"Property_13\":\"Property Value of Property_13\"",
"\"Property_12\":\"Property Value of Property_12\"",
"\"Property_11\":\"Property Value of Property_11\"",
"\"Property_10\":\"Property Value of Property_10\"",
"\"Property_9\":\"Property Value of Property_9\"",
"\"Property_8\":\"Property Value of Property_8\"",
"\"Property_7\":\"Property Value of Property_7\"",
"\"Property_6\":\"Property Value of Property_6\"",
"\"Property_5\":\"Property Value of Property_5\"",
"\"Property_4\":\"Property Value of Property_4\"",
"\"Property_3\":\"Property Value of Property_3\"",
"\"Property_2\":\"Property Value of Property_2\"",
"\"Property_1\":\"Property Value of Property_1\"");
} finally {
engineProxy.returnConnection();
}
// verify that the map is correctly retrieved from the database
Task retrievedTask = taskService.getTask(createdTask.getId());
Map<String, String> customAttributesFromDb = retrievedTask.getCustomAttributes();
assertNotNull(customAttributesFromDb);
assertEquals(customAttributesFromDb, customAttributesForCreate);
assertThat(customAttributesFromDb).isNotNull();
assertThat(customAttributesForCreate).isEqualTo(customAttributesFromDb);
}
@WithAccessId(
@ -333,8 +338,8 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertThat(createdTask.getId()).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
// verify that the database content is as expected
TaskanaEngineProxyForTest engineProxy = new TaskanaEngineProxyForTest(taskanaEngine);
@ -344,44 +349,54 @@ class CreateTaskAccTest extends AbstractAccTest {
engineProxy.openConnection();
String customProperties =
mapper.getCustomAttributesAsString(createdTask.getAttachments().get(0).getId());
assertTrue(customProperties.contains("\"Property_26\":\"Property Value of Property_26\""));
assertTrue(customProperties.contains("\"Property_25\":\"Property Value of Property_25\""));
assertTrue(customProperties.contains("\"Property_21\":\"Property Value of Property_21\""));
assertTrue(customProperties.contains("\"Property_19\":\"Property Value of Property_19\""));
assertTrue(customProperties.contains("\"Property_16\":\"Property Value of Property_16\""));
assertTrue(customProperties.contains("\"Property_12\":\"Property Value of Property_12\""));
assertTrue(customProperties.contains("\"Property_11\":\"Property Value of Property_11\""));
assertTrue(customProperties.contains("\"Property_7\":\"Property Value of Property_7\""));
assertTrue(customProperties.contains("\"Property_6\":\"Property Value of Property_6\""));
assertThat(customProperties.contains("\"Property_26\":\"Property Value of Property_26\""))
.isTrue();
assertThat(customProperties.contains("\"Property_25\":\"Property Value of Property_25\""))
.isTrue();
assertThat(customProperties.contains("\"Property_21\":\"Property Value of Property_21\""))
.isTrue();
assertThat(customProperties.contains("\"Property_19\":\"Property Value of Property_19\""))
.isTrue();
assertThat(customProperties.contains("\"Property_16\":\"Property Value of Property_16\""))
.isTrue();
assertThat(customProperties.contains("\"Property_12\":\"Property Value of Property_12\""))
.isTrue();
assertThat(customProperties.contains("\"Property_11\":\"Property Value of Property_11\""))
.isTrue();
assertThat(customProperties.contains("\"Property_7\":\"Property Value of Property_7\""))
.isTrue();
assertThat(customProperties.contains("\"Property_6\":\"Property Value of Property_6\""))
.isTrue();
} finally {
engineProxy.returnConnection();
}
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertThat(readTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertNotNull(readTask.getAttachments());
assertEquals(1, readTask.getAttachments().size());
assertNotNull(readTask.getAttachments().get(0).getCreated());
assertNotNull(readTask.getAttachments().get(0).getModified());
assertEquals(
readTask.getAttachments().get(0).getCreated(),
readTask.getAttachments().get(0).getModified());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getId());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getKey());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getType());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getCategory());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getDomain());
assertNotNull(readTask.getAttachments().get(0).getClassificationSummary().getServiceLevel());
assertNotNull(readTask.getAttachments().get(0).getReceived());
assertNotNull(readTask.getAttachments().get(0).getChannel());
assertNotNull(readTask.getAttachments().get(0).getObjectReference());
assertThat(readTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(readTask.getAttachments()).isNotNull();
assertThat(readTask.getAttachments()).hasSize(1);
assertThat(readTask.getAttachments().get(0).getCreated()).isNotNull();
assertThat(readTask.getAttachments().get(0).getModified()).isNotNull();
assertThat(readTask.getAttachments().get(0).getModified())
.isEqualTo(readTask.getAttachments().get(0).getCreated());
assertThat(readTask.getAttachments().get(0).getClassificationSummary()).isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getId()).isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getKey()).isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getType()).isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getCategory())
.isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getDomain()).isNotNull();
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getServiceLevel())
.isNotNull();
assertThat(readTask.getAttachments().get(0).getReceived()).isNotNull();
assertThat(readTask.getAttachments().get(0).getChannel()).isNotNull();
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
// verify that the map is correctly retrieved from the database
Map<String, String> customAttributesFromDb =
readTask.getAttachments().get(0).getCustomAttributes();
assertNotNull(customAttributesFromDb);
assertEquals(customAttributesFromDb, customAttributesForCreate);
assertThat(customAttributesFromDb).isNotNull();
assertThat(customAttributesForCreate).isEqualTo(customAttributesFromDb);
}
@WithAccessId(
@ -422,21 +437,20 @@ class CreateTaskAccTest extends AbstractAccTest {
createSimpleCustomProperties(3)));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertThat(createdTask.getId()).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertThat(readTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertNotNull(readTask.getAttachments());
assertEquals(2, readTask.getAttachments().size());
assertNotNull(readTask.getAttachments().get(1).getCreated());
assertNotNull(readTask.getAttachments().get(1).getModified());
assertEquals(
readTask.getAttachments().get(0).getCreated(),
readTask.getAttachments().get(1).getModified());
// assertNotNull(readTask.getAttachments().get(0).getClassification());
assertNotNull(readTask.getAttachments().get(0).getObjectReference());
assertThat(readTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(readTask.getAttachments()).isNotNull();
assertThat(readTask.getAttachments()).hasSize(2);
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
assertThat(readTask.getAttachments().get(1).getModified())
.isEqualTo(readTask.getAttachments().get(0).getCreated());
// assertThat(readTask.getAttachments().get(0).getClassification()).isNotNull();
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
}
@WithAccessId(
@ -450,7 +464,7 @@ class CreateTaskAccTest extends AbstractAccTest {
// SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
long serviceLevelDays = Duration.parse(classification.getServiceLevel()).toDays();
assertTrue(serviceLevelDays > 5);
assertThat(serviceLevelDays > 5).isTrue();
Task newTask = taskService.newTask("USER_1_1", classification.getDomain());
newTask.setClassificationKey(classification.getKey());
@ -460,18 +474,18 @@ class CreateTaskAccTest extends AbstractAccTest {
Instant planned = Instant.now().plus(10, ChronoUnit.DAYS);
newTask.setPlanned(planned);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getId()).isNotNull();
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertEquals(planned, readTask.getPlanned());
assertThat(readTask).isNotNull();
assertThat(readTask.getPlanned()).isEqualTo(planned);
long calendarDays =
WorkingDaysToDaysConverter.initialize()
.convertWorkingDaysToDays(readTask.getPlanned(), serviceLevelDays);
Instant shouldBeDueDate = readTask.getPlanned().plus(Duration.ofDays(calendarDays));
assertEquals(readTask.getDue(), shouldBeDueDate);
assertThat(shouldBeDueDate).isEqualTo(readTask.getDue());
}
@WithAccessId(
@ -485,7 +499,7 @@ class CreateTaskAccTest extends AbstractAccTest {
// SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
long serviceLevelDays = Duration.parse(classification.getServiceLevel()).toDays();
assertTrue(serviceLevelDays > 5);
assertThat(serviceLevelDays > 5).isTrue();
Task newTask = taskService.newTask("USER_1_1", classification.getDomain());
newTask.setClassificationKey(classification.getKey());
@ -495,20 +509,20 @@ class CreateTaskAccTest extends AbstractAccTest {
Instant due = Instant.now().plus(40, ChronoUnit.DAYS);
newTask.setDue(due);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getId()).isNotNull();
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertEquals(due, readTask.getDue());
assertThat(readTask).isNotNull();
assertThat(readTask.getDue()).isEqualTo(due);
long calendarDaysToSubstract =
WorkingDaysToDaysConverter.initialize().convertWorkingDaysToDays(due, -serviceLevelDays);
assertTrue(calendarDaysToSubstract < 0);
assertTrue(calendarDaysToSubstract <= -serviceLevelDays);
assertThat(calendarDaysToSubstract < 0).isTrue();
assertThat(calendarDaysToSubstract <= -serviceLevelDays).isTrue();
Instant shouldBePlannedDate = due.plus(Duration.ofDays(calendarDaysToSubstract));
assertEquals(readTask.getPlanned(), shouldBePlannedDate);
assertThat(shouldBePlannedDate).isEqualTo(readTask.getPlanned());
}
@WithAccessId(
@ -550,28 +564,28 @@ class CreateTaskAccTest extends AbstractAccTest {
createSimpleCustomProperties(3)));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertThat(createdTask.getId()).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertThat(readTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertNotNull(readTask.getAttachments());
assertEquals(2, readTask.getAttachments().size());
assertNotNull(readTask.getAttachments().get(1).getCreated());
assertNotNull(readTask.getAttachments().get(1).getModified());
assertEquals(
readTask.getAttachments().get(0).getCreated(),
readTask.getAttachments().get(1).getModified());
// assertNotNull(readTask.getAttachments().get(0).getClassification());
assertNotNull(readTask.getAttachments().get(0).getObjectReference());
assertThat(readTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(readTask.getAttachments()).isNotNull();
assertThat(readTask.getAttachments()).hasSize(2);
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
assertThat(readTask.getAttachments().get(1).getModified())
.isEqualTo(readTask.getAttachments().get(0).getCreated());
// assertThat(readTask.getAttachments().get(0).getClassification()).isNotNull();
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
assertEquals(99, readTask.getPriority());
assertThat(readTask.getPriority()).isEqualTo(99);
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1);
assertEquals(readTask.getDue(), readTask.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(readTask.getPlanned().plus(Duration.ofDays(calendarDays)))
.isEqualTo(readTask.getDue());
}
@WithAccessId(
@ -584,10 +598,15 @@ class CreateTaskAccTest extends AbstractAccTest {
(Attachment invalidAttachment) -> {
Task taskWithInvalidAttachment = makeNewTask(taskService);
taskWithInvalidAttachment.addAttachment(invalidAttachment);
Assertions.assertThrows(
InvalidArgumentException.class,
() -> taskService.createTask(taskWithInvalidAttachment),
"Should have thrown an InvalidArgumentException, because Attachment-ObjRef is null.");
ThrowingCallable call =
() -> {
taskService.createTask(taskWithInvalidAttachment);
};
assertThatThrownBy(call)
.describedAs(
"Should have thrown an InvalidArgumentException, "
+ "because Attachment-ObjRef is null.")
.isInstanceOf(InvalidArgumentException.class);
};
testCreateTask.accept(
@ -670,9 +689,9 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setName("Test Name");
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertEquals("Test Name", createdTask.getName());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(createdTask.getName()).isEqualTo("Test Name");
}
@WithAccessId(
@ -690,10 +709,9 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setName("Test Name");
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertEquals(
2, createdTask.getPriority()); // priority is 22 in DOMAIN_B, task is created in DOMAIN_A
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(createdTask.getPriority()).isEqualTo(2);
}
@WithAccessId(
@ -707,8 +725,11 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> taskService.createTask(newTask));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@WithAccessId(
@ -722,7 +743,11 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Assertions.assertThrows(NotAuthorizedException.class, () -> taskService.createTask(newTask));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -738,10 +763,14 @@ class CreateTaskAccTest extends AbstractAccTest {
if (objectReference != null) {
newTask.setPrimaryObjRef(objectReference);
}
Assertions.assertThrows(
InvalidArgumentException.class,
() -> taskService.createTask(newTask),
"Should have thrown an InvalidArgumentException, because ObjRef-ObjRef is null.");
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatThrownBy(call)
.describedAs(
"Should have thrown an InvalidArgumentException, because ObjRef-ObjRef is null.")
.isInstanceOf(InvalidArgumentException.class);
};
testCreateTask.accept(null);
@ -772,10 +801,10 @@ class CreateTaskAccTest extends AbstractAccTest {
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertNotNull(createdTask.getDomain());
assertEquals(workbasket.getDomain(), createdTask.getDomain());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(createdTask.getDomain()).isNotNull();
assertThat(createdTask.getDomain()).isEqualTo(workbasket.getDomain());
}
@WithAccessId(
@ -811,7 +840,7 @@ class CreateTaskAccTest extends AbstractAccTest {
Task createdTask = taskService.createTask(newTask);
Task readTask = taskService.getTask(createdTask.getId());
assertEquals(createdTask, readTask);
assertThat(readTask).isEqualTo(createdTask);
}
@WithAccessId(
@ -834,23 +863,23 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setCallbackInfo(callbackInfo);
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask);
assertEquals("1234567", createdTask.getPrimaryObjRef().getValue());
assertNotNull(createdTask.getCreated());
assertNotNull(createdTask.getModified());
assertNotNull(createdTask.getBusinessProcessId());
assertNull(createdTask.getClaimed());
assertNull(createdTask.getCompleted());
assertEquals(createdTask.getCreated(), createdTask.getModified());
assertEquals(createdTask.getCreated(), createdTask.getPlanned());
assertEquals(TaskState.READY, createdTask.getState());
assertNull(createdTask.getParentBusinessProcessId());
assertEquals(2, createdTask.getPriority());
assertFalse(createdTask.isRead());
assertFalse(createdTask.isTransferred());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
assertThat(createdTask.getCreated()).isNotNull();
assertThat(createdTask.getModified()).isNotNull();
assertThat(createdTask.getBusinessProcessId()).isNotNull();
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
assertThat(createdTask.isRead()).isFalse();
assertThat(createdTask.isTransferred()).isFalse();
Task retrievedTask = taskService.getTask(createdTask.getId());
assertEquals(callbackInfo, retrievedTask.getCallbackInfo());
assertThat(retrievedTask.getCallbackInfo()).isEqualTo(callbackInfo);
}
@Test
@ -861,7 +890,11 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_B", "SYSTEM_B", "INSTANCE_B", "VNR", "1234567"));
Assertions.assertThrows(NotAuthorizedException.class, () -> taskService.createTask(newTask));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -872,8 +905,11 @@ class CreateTaskAccTest extends AbstractAccTest {
Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000");
Assertions.assertThrows(
TaskAlreadyExistException.class, () -> taskService.createTask(existingTask));
ThrowingCallable call =
() -> {
taskService.createTask(existingTask);
};
assertThatThrownBy(call).isInstanceOf(TaskAlreadyExistException.class);
}
@WithAccessId(
@ -884,7 +920,11 @@ class CreateTaskAccTest extends AbstractAccTest {
Task task = taskService.newTask("TEAMLEAD_2", "DOMAIN_A");
Assertions.assertThrows(NotAuthorizedException.class, () -> taskService.createTask(task));
ThrowingCallable call =
() -> {
taskService.createTask(task);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(

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

@ -1,15 +1,12 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -39,9 +36,11 @@ class DeleteTaskAccTest extends AbstractAccTest {
void testDeleteSingleTaskNotAuthorized() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskService.deleteTask("TKI:000000000000000000000000000000000037"));
ThrowingCallable call =
() -> {
taskService.deleteTask("TKI:000000000000000000000000000000000037");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -56,9 +55,11 @@ class DeleteTaskAccTest extends AbstractAccTest {
taskService.deleteTask(task.getId());
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.getTask("TKI:000000000000000000000000000000000036"));
ThrowingCallable call =
() -> {
taskService.getTask("TKI:000000000000000000000000000000000036");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -70,8 +71,11 @@ class DeleteTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000029");
Assertions.assertThrows(
InvalidStateException.class, () -> taskService.deleteTask(task.getId()));
ThrowingCallable call =
() -> {
taskService.deleteTask(task.getId());
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(
@ -83,16 +87,21 @@ class DeleteTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
Assertions.assertThrows(
InvalidStateException.class,
() -> taskService.deleteTask(task.getId()),
"Should not be possible to delete claimed task without force flag");
ThrowingCallable call =
() -> {
taskService.deleteTask(task.getId());
};
assertThatThrownBy(call)
.describedAs("Should not be possible to delete claimed task without force flag")
.isInstanceOf(InvalidStateException.class);
taskService.forceDeleteTask(task.getId());
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.getTask("TKI:000000000000000000000000000000000027"));
call =
() -> {
taskService.getTask("TKI:000000000000000000000000000000000027");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -108,10 +117,12 @@ class DeleteTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
assertFalse(results.containsErrors());
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.getTask("TKI:000000000000000000000000000000000038"));
assertThat(results.containsErrors()).isFalse();
ThrowingCallable call =
() -> {
taskService.getTask("TKI:000000000000000000000000000000000038");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -130,16 +141,19 @@ class DeleteTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
String expectedFailedId = "TKI:000000000000000000000000000000000028";
assertTrue(results.containsErrors());
assertThat(results.containsErrors()).isTrue();
List<String> failedTaskIds = results.getFailedIds();
assertEquals(1, failedTaskIds.size());
assertEquals(expectedFailedId, failedTaskIds.get(0));
assertSame(results.getErrorMap().get(expectedFailedId).getClass(), InvalidStateException.class);
assertThat(failedTaskIds).hasSize(1);
assertThat(failedTaskIds.get(0)).isEqualTo(expectedFailedId);
assertThat(InvalidStateException.class)
.isSameAs(results.getErrorMap().get(expectedFailedId).getClass());
Task notDeletedTask = taskService.getTask("TKI:000000000000000000000000000000000028");
assertNotNull(notDeletedTask);
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.getTask("TKI:000000000000000000000000000000000040"));
assertThat(notDeletedTask).isNotNull();
ThrowingCallable call =
() -> {
taskService.getTask("TKI:000000000000000000000000000000000040");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
}

101
lib/taskana-core/src/test/java/acceptance/task/GetTaskAccTest.java
View File

@ -1,13 +1,11 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.HashMap;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -38,48 +36,49 @@ class GetTaskAccTest extends AbstractAccTest {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
assertNull(task.getCompleted());
assertEquals("Task99", task.getName());
assertEquals("creator_user_id", task.getCreator());
assertEquals("Lorem ipsum was n Quatsch dolor sit amet.", task.getDescription());
assertEquals("Some custom Note", task.getNote());
assertEquals(1, task.getPriority());
assertEquals(TaskState.CLAIMED, task.getState());
assertEquals("MANUAL", task.getClassificationCategory());
assertEquals("T2000", task.getClassificationSummary().getKey());
assertEquals(
"CLI:100000000000000000000000000000000016", task.getClassificationSummary().getId());
assertEquals("WBI:100000000000000000000000000000000006", task.getWorkbasketSummary().getId());
assertEquals("USER_1_1", task.getWorkbasketKey());
assertEquals("DOMAIN_A", task.getDomain());
assertEquals("BPI21", task.getBusinessProcessId());
assertEquals("PBPI21", task.getParentBusinessProcessId());
assertEquals("user_1_1", task.getOwner());
assertEquals("MyCompany1", task.getPrimaryObjRef().getCompany());
assertEquals("MySystem1", task.getPrimaryObjRef().getSystem());
assertEquals("MyInstance1", task.getPrimaryObjRef().getSystemInstance());
assertEquals("MyType1", task.getPrimaryObjRef().getType());
assertEquals("MyValue1", task.getPrimaryObjRef().getValue());
assertTrue(task.isRead());
assertFalse(task.isTransferred());
assertEquals(new HashMap<String, String>(), task.getCallbackInfo());
assertEquals(new HashMap<String, String>(), task.getCustomAttributes());
assertEquals("custom1", task.getCustomAttribute("1"));
assertEquals("custom2", task.getCustomAttribute("2"));
assertEquals("custom3", task.getCustomAttribute("3"));
assertEquals("custom4", task.getCustomAttribute("4"));
assertEquals("custom5", task.getCustomAttribute("5"));
assertEquals("custom6", task.getCustomAttribute("6"));
assertEquals("custom7", task.getCustomAttribute("7"));
assertEquals("custom8", task.getCustomAttribute("8"));
assertEquals("custom9", task.getCustomAttribute("9"));
assertEquals("custom10", task.getCustomAttribute("10"));
assertEquals("custom11", task.getCustomAttribute("11"));
assertEquals("custom12", task.getCustomAttribute("12"));
assertEquals("custom13", task.getCustomAttribute("13"));
assertEquals("abc", task.getCustomAttribute("14"));
assertEquals("custom15", task.getCustomAttribute("15"));
assertEquals("custom16", task.getCustomAttribute("16"));
assertThat(task.getCompleted()).isNull();
assertThat(task.getName()).isEqualTo("Task99");
assertThat(task.getCreator()).isEqualTo("creator_user_id");
assertThat(task.getDescription()).isEqualTo("Lorem ipsum was n Quatsch dolor sit amet.");
assertThat(task.getNote()).isEqualTo("Some custom Note");
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getState()).isEqualTo(TaskState.CLAIMED);
assertThat(task.getClassificationCategory()).isEqualTo("MANUAL");
assertThat(task.getClassificationSummary().getKey()).isEqualTo("T2000");
assertThat(task.getClassificationSummary().getId())
.isEqualTo("CLI:100000000000000000000000000000000016");
assertThat(task.getWorkbasketSummary().getId())
.isEqualTo("WBI:100000000000000000000000000000000006");
assertThat(task.getWorkbasketKey()).isEqualTo("USER_1_1");
assertThat(task.getDomain()).isEqualTo("DOMAIN_A");
assertThat(task.getBusinessProcessId()).isEqualTo("BPI21");
assertThat(task.getParentBusinessProcessId()).isEqualTo("PBPI21");
assertThat(task.getOwner()).isEqualTo("user_1_1");
assertThat(task.getPrimaryObjRef().getCompany()).isEqualTo("MyCompany1");
assertThat(task.getPrimaryObjRef().getSystem()).isEqualTo("MySystem1");
assertThat(task.getPrimaryObjRef().getSystemInstance()).isEqualTo("MyInstance1");
assertThat(task.getPrimaryObjRef().getType()).isEqualTo("MyType1");
assertThat(task.getPrimaryObjRef().getValue()).isEqualTo("MyValue1");
assertThat(task.isRead()).isTrue();
assertThat(task.isTransferred()).isFalse();
assertThat(task.getCallbackInfo()).isEqualTo(new HashMap<String, String>());
assertThat(task.getCustomAttributes()).isEqualTo(new HashMap<String, String>());
assertThat(task.getCustomAttribute("1")).isEqualTo("custom1");
assertThat(task.getCustomAttribute("2")).isEqualTo("custom2");
assertThat(task.getCustomAttribute("3")).isEqualTo("custom3");
assertThat(task.getCustomAttribute("4")).isEqualTo("custom4");
assertThat(task.getCustomAttribute("5")).isEqualTo("custom5");
assertThat(task.getCustomAttribute("6")).isEqualTo("custom6");
assertThat(task.getCustomAttribute("7")).isEqualTo("custom7");
assertThat(task.getCustomAttribute("8")).isEqualTo("custom8");
assertThat(task.getCustomAttribute("9")).isEqualTo("custom9");
assertThat(task.getCustomAttribute("10")).isEqualTo("custom10");
assertThat(task.getCustomAttribute("11")).isEqualTo("custom11");
assertThat(task.getCustomAttribute("12")).isEqualTo("custom12");
assertThat(task.getCustomAttribute("13")).isEqualTo("custom13");
assertThat(task.getCustomAttribute("14")).isEqualTo("abc");
assertThat(task.getCustomAttribute("15")).isEqualTo("custom15");
assertThat(task.getCustomAttribute("16")).isEqualTo("custom16");
}
@WithAccessId(
@ -89,6 +88,12 @@ class GetTaskAccTest extends AbstractAccTest {
void testGetTaskByIdNotExisting() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(TaskNotFoundException.class, () -> taskService.getTask("INVALID"));
// Assertions.assertThrows(TaskNotFoundException.class, () ->
// taskService.getTask("INVALID"));
ThrowingCallable call =
() -> {
taskService.getTask("INVALID");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
}

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

@ -1,7 +1,6 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -43,8 +42,8 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.ownerLike("%user%")
.orderByOwner(desc)
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, null);
assertNotNull(columnValueList);
assertEquals(8, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(8);
}
@WithAccessId(
@ -59,8 +58,8 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.ownerLike("%user%")
.orderByClassificationName(asc)
.listValues(TaskQueryColumnName.CLASSIFICATION_NAME, null);
assertNotNull(columnValueList);
assertEquals(5, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(5);
}
@WithAccessId(
@ -71,11 +70,11 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> tasks =
taskService.createTaskQuery().classificationNameIn("Dynamik-Ablehnung").list();
assertEquals(1, tasks.size());
assertThat(tasks).hasSize(1);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertNotNull(attachmentSummaries);
assertEquals(2, attachmentSummaries.size());
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).hasSize(2);
tasks =
taskService
@ -83,7 +82,7 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.classificationNameIn("Dynamik-Ablehnung")
.orderByClassificationName(SortDirection.ASCENDING)
.list();
assertEquals(1, tasks.size());
assertThat(tasks).hasSize(1);
}
@WithAccessId(
@ -98,11 +97,11 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.classificationNameLike("Dynamik%", "Widerruf")
.orderByClassificationName(SortDirection.ASCENDING)
.list();
assertEquals(32, tasks.size());
assertThat(tasks).hasSize(32);
// without sort, the same number of tasks should be returned
tasks = taskService.createTaskQuery().classificationNameLike("Dynamik%", "Widerruf").list();
assertEquals(32, tasks.size());
assertThat(tasks).hasSize(32);
}
@WithAccessId(
@ -118,14 +117,14 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.attachmentClassificationNameLike("Widerruf", "Beratungsprotokoll", "Dynamik%")
.orderByAttachmentClassificationName(SortDirection.ASCENDING)
.list();
assertEquals(7, tasks.size());
assertThat(tasks).hasSize(7);
// make sure that unordered query returns the same number of objects
tasks =
taskService
.createTaskQuery()
.attachmentClassificationNameLike("Widerruf", "Beratungsprotokoll", "Dynamik%")
.list();
assertEquals(7, tasks.size());
assertThat(tasks).hasSize(7);
}
@WithAccessId(
@ -141,14 +140,14 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
.attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung")
.orderByAttachmentClassificationName(SortDirection.ASCENDING)
.list();
assertEquals(4, tasks.size());
assertThat(tasks).hasSize(4);
// make sure that unordered query returns the same number of objects
tasks =
taskService
.createTaskQuery()
.attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung")
.list();
assertEquals(4, tasks.size());
assertThat(tasks).hasSize(4);
}
@WithAccessId(
@ -162,7 +161,7 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
taskQuery.classificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung").list();
long numberOfTasks =
taskQuery.classificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung").count();
assertEquals(numberOfTasks, tasks.size());
assertThat(tasks).hasSize((int)numberOfTasks);
}
@WithAccessId(
@ -179,12 +178,12 @@ class QueryTaskByClassificationNameAccTest extends AbstractAccTest {
// we expect 4 result objects in this case, because task
// TKI:000000000000000000000000000000000001 has 2 attachments with different Classifications
// therefore task TKI:000000000000000000000000000000000001 occurs twice in the result set
assertEquals(4, tasks.size());
assertThat(tasks).hasSize(4);
long numberOfTasks =
taskQuery
.attachmentClassificationNameIn("Widerruf", "Beratungsprotokoll", "Dynamikänderung")
.count();
assertEquals(3, numberOfTasks);
assertThat(numberOfTasks).isEqualTo(3);
// the count returns only the number of tasks that have an attachment with the specified
// classification name.
// therefore, task 001 is counted only once.

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

@ -1,9 +1,7 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.util.IterableUtil.toArray;
import acceptance.AbstractAccTest;
import java.util.Comparator;
@ -30,6 +28,8 @@ import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class)
class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
private static final Comparator<Object> REFERENCE_COMPARATOR = (o1, o2) -> o1 == o2 ? 0 : -1;
QueryTaskWithAttachmentAccTest() {
super();
}
@ -41,11 +41,11 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
void testGetAttachmentSummariesFromTask() {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> tasks = taskService.createTaskQuery().classificationKeyIn("L110102").list();
assertEquals(1, tasks.size());
assertThat(tasks).hasSize(1);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertNotNull(attachmentSummaries);
assertEquals(2, attachmentSummaries.size());
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).hasSize(2);
}
@WithAccessId(userName = "user_1_2")
@ -53,11 +53,11 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
void testGetNoAttachmentSummaryFromTask() {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> tasks = taskService.createTaskQuery().list();
assertEquals(30, tasks.size());
assertThat(tasks).hasSize(30);
List<AttachmentSummary> attachmentSummaries = tasks.get(0).getAttachmentSummaries();
assertNotNull(attachmentSummaries);
assertTrue(attachmentSummaries.isEmpty());
assertThat(attachmentSummaries).isNotNull();
assertThat(attachmentSummaries).isEmpty();
}
@WithAccessId(
@ -67,8 +67,8 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
void testIfNewTaskHasEmptyAttachmentList() {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.newTask("WBI:100000000000000000000000000000000006");
assertNotNull(task.getAttachments());
assertNotNull(task.asSummary().getAttachmentSummaries());
assertThat(task.getAttachments()).isNotNull();
assertThat(task.asSummary().getAttachmentSummaries()).isNotNull();
}
@WithAccessId(
@ -81,48 +81,20 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
// find Task with ID TKI:00...00
List<TaskSummary> tasks =
taskService.createTaskQuery().idIn("TKI:000000000000000000000000000000000000").list();
assertEquals(1, tasks.size());
List<AttachmentSummary> queryAttachmentSummaries =
tasks.get(0).getAttachmentSummaries().stream()
.sorted(Comparator.comparing(AttachmentSummary::getId))
.collect(Collectors.toList());
assertThat(tasks).hasSize(1);
List<AttachmentSummary> queryAttachmentSummaries = tasks.get(0).getAttachmentSummaries();
Task originalTask = taskService.getTask("TKI:000000000000000000000000000000000000");
List<Attachment> originalAttachments =
List<AttachmentSummary> originalAttachments =
originalTask.getAttachments().stream()
.sorted(Comparator.comparing(Attachment::getId))
.map(Attachment::asSummary)
.collect(Collectors.toList());
assertEquals(originalAttachments.size(), queryAttachmentSummaries.size());
for (int i = 0; i < queryAttachmentSummaries.size(); i++) {
// Test if it's the Summary of the Original Attachment
assertEquals(originalAttachments.get(i).asSummary(), queryAttachmentSummaries.get(i));
// Test if the values are correct
assertEquals(
originalAttachments.get(i).getChannel(), queryAttachmentSummaries.get(i).getChannel());
assertEquals(
originalAttachments.get(i).getClassificationSummary(),
queryAttachmentSummaries.get(i).getClassificationSummary());
assertEquals(
originalAttachments.get(i).getCreated(), queryAttachmentSummaries.get(i).getCreated());
assertEquals(originalAttachments.get(i).getId(), queryAttachmentSummaries.get(i).getId());
assertEquals(
originalAttachments.get(i).getModified(), queryAttachmentSummaries.get(i).getModified());
assertEquals(
originalAttachments.get(i).getObjectReference(),
queryAttachmentSummaries.get(i).getObjectReference());
assertEquals(
originalAttachments.get(i).getReceived(), queryAttachmentSummaries.get(i).getReceived());
assertEquals(
originalAttachments.get(i).getTaskId(), queryAttachmentSummaries.get(i).getTaskId());
// Verify that they're not the same Object
assertNotEquals(
originalAttachments.get(i).hashCode(), queryAttachmentSummaries.get(i).hashCode());
assertNotEquals(
originalAttachments.get(i).getClass(), queryAttachmentSummaries.get(i).getClass());
}
assertThat(queryAttachmentSummaries)
.hasSize(originalAttachments.size())
.containsOnly(toArray(originalAttachments)) // same values
.usingElementComparator(REFERENCE_COMPARATOR)
.doesNotContain(toArray(originalAttachments)); // but not same reference
}
@WithAccessId(
@ -139,47 +111,19 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
.classificationKeyIn("T2000")
.customAttributeIn("1", "custom1")
.list();
assertEquals(1, tasks.size());
List<AttachmentSummary> queryAttachmentSummaries =
tasks.get(0).getAttachmentSummaries().stream()
.sorted(Comparator.comparing(AttachmentSummary::getId))
.collect(Collectors.toList());
assertThat(tasks).hasSize(1);
List<AttachmentSummary> queryAttachmentSummaries = tasks.get(0).getAttachmentSummaries();
Task originalTask = taskService.getTask("TKI:000000000000000000000000000000000000");
List<Attachment> originalAttachments =
List<AttachmentSummary> originalAttachments =
originalTask.getAttachments().stream()
.sorted(Comparator.comparing(Attachment::getId))
.map(Attachment::asSummary)
.collect(Collectors.toList());
assertEquals(originalAttachments.size(), queryAttachmentSummaries.size());
for (int i = 0; i < queryAttachmentSummaries.size(); i++) {
// Test if it's the Summary of the Original Attachment
assertEquals(originalAttachments.get(i).asSummary(), queryAttachmentSummaries.get(i));
// Test if the values are correct
assertEquals(
originalAttachments.get(i).getChannel(), queryAttachmentSummaries.get(i).getChannel());
assertEquals(
originalAttachments.get(i).getClassificationSummary(),
queryAttachmentSummaries.get(i).getClassificationSummary());
assertEquals(
originalAttachments.get(i).getCreated(), queryAttachmentSummaries.get(i).getCreated());
assertEquals(originalAttachments.get(i).getId(), queryAttachmentSummaries.get(i).getId());
assertEquals(
originalAttachments.get(i).getModified(), queryAttachmentSummaries.get(i).getModified());
assertEquals(
originalAttachments.get(i).getObjectReference(),
queryAttachmentSummaries.get(i).getObjectReference());
assertEquals(
originalAttachments.get(i).getReceived(), queryAttachmentSummaries.get(i).getReceived());
assertEquals(
originalAttachments.get(i).getTaskId(), queryAttachmentSummaries.get(i).getTaskId());
// Verify that they're not the same Object
assertNotEquals(
originalAttachments.get(i).hashCode(), queryAttachmentSummaries.get(i).hashCode());
assertNotEquals(
originalAttachments.get(i).getClass(), queryAttachmentSummaries.get(i).getClass());
}
assertThat(queryAttachmentSummaries)
.hasSize(originalAttachments.size())
.containsOnly(toArray(originalAttachments)) // same values
.usingElementComparator(REFERENCE_COMPARATOR)
.doesNotContain(toArray(originalAttachments)); // but not same reference
}
}

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

File diff suppressed because it is too large Load Diff

8
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByObjectReferenceAccTest.java
View File

@ -1,6 +1,6 @@
package acceptance.task;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -29,7 +29,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceValueIn("11223344", "22334455").list();
assertEquals(33L, results.size());
assertThat(results).hasSize(33);
}
@WithAccessId(
@ -44,7 +44,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
.primaryObjectReferenceTypeIn("SDNR")
.primaryObjectReferenceValueIn("11223344")
.list();
assertEquals(10L, results.size());
assertThat(results).hasSize(10);
}
@WithAccessId(
@ -55,6 +55,6 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceValueLike("%567%").list();
assertEquals(10L, results.size());
assertThat(results).hasSize(10);
}
}

53
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByTimeIntervalsAccTest.java
View File

@ -1,9 +1,6 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.time.Instant;
@ -47,14 +44,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
.orderByCreated(asc)
.list();
assertThat(results.size(), equalTo(50));
assertThat(results).hasSize(50);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getCreated();
assertTrue(interval1.contains(cr) || interval2.contains(cr));
assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getCreated().isAfter(taskSummary.getCreated()));
assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse();
}
previousSummary = taskSummary;
}
@ -72,14 +69,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
assertThat(results.size(), equalTo(37));
assertThat(results).hasSize(37);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getCreated();
assertTrue(interval1.contains(cr));
assertThat(interval1.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getCreated().isAfter(taskSummary.getCreated()));
assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse();
}
previousSummary = taskSummary;
}
@ -97,14 +94,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().createdWithin(interval1).orderByCreated(asc).list();
assertThat(results.size(), equalTo(48));
assertThat(results).hasSize(48);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getCreated();
assertTrue(interval1.contains(cr));
assertThat(interval1.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getCreated().isAfter(taskSummary.getCreated()));
assertThat(previousSummary.getCreated().isAfter(taskSummary.getCreated())).isFalse();
}
previousSummary = taskSummary;
}
@ -129,14 +126,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
.orderByCreated(asc)
.list();
assertThat(results.size(), equalTo(35));
assertThat(results).hasSize(35);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getClaimed();
assertTrue(interval1.contains(cr) || interval2.contains(cr));
assertThat(interval1.contains(cr) || interval2.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getClaimed().isAfter(taskSummary.getClaimed()));
assertThat(previousSummary.getClaimed().isAfter(taskSummary.getClaimed())).isFalse();
}
previousSummary = taskSummary;
}
@ -154,14 +151,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().completedWithin(interval).orderByCompleted(asc).list();
assertThat(results.size(), equalTo(15));
assertThat(results).hasSize(15);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getCompleted();
assertTrue(interval.contains(cr));
assertThat(interval.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getCompleted().isAfter(taskSummary.getCompleted()));
assertThat(previousSummary.getCompleted().isAfter(taskSummary.getCompleted())).isFalse();
}
previousSummary = taskSummary;
}
@ -179,14 +176,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().modifiedWithin(interval).orderByModified(asc).list();
assertThat(results.size(), equalTo(6));
assertThat(results).hasSize(6);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getModified();
assertTrue(interval.contains(cr));
assertThat(interval.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getModified().isAfter(taskSummary.getModified()));
assertThat(previousSummary.getModified().isAfter(taskSummary.getModified())).isFalse();
}
previousSummary = taskSummary;
}
@ -204,14 +201,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().plannedWithin(interval).orderByPlanned(asc).list();
assertThat(results.size(), equalTo(81));
assertThat(results).hasSize(81);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getPlanned();
assertTrue(interval.contains(cr));
assertThat(interval.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getPlanned().isAfter(taskSummary.getPlanned()));
assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse();
}
previousSummary = taskSummary;
}
@ -229,14 +226,14 @@ class QueryTasksByTimeIntervalsAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService.createTaskQuery().dueWithin(interval).orderByPlanned(asc).list();
assertThat(results.size(), equalTo(81));
assertThat(results).hasSize(81);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
Instant cr = taskSummary.getDue();
assertTrue(interval.contains(cr));
assertThat(interval.contains(cr)).isTrue();
if (previousSummary != null) {
assertFalse(previousSummary.getPlanned().isAfter(taskSummary.getPlanned()));
assertThat(previousSummary.getPlanned().isAfter(taskSummary.getPlanned())).isFalse();
}
previousSummary = taskSummary;
}

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

@ -1,13 +1,13 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -40,7 +40,7 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(workbasketIdentifiers.toArray(new KeyDomain[0]))
.list();
assertThat(results.size(), equalTo(52));
assertThat(results).hasSize(52);
String[] ids =
results.stream()
@ -49,7 +49,7 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
.toArray(new String[0]);
List<TaskSummary> result2 = taskService.createTaskQuery().workbasketIdIn(ids).list();
assertThat(result2.size(), equalTo(52));
assertThat(result2).hasSize(52);
}
@WithAccessId(
@ -59,13 +59,14 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
void testThrowsExceptionIfNoOpenerPermissionOnQueriedWorkbasket() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
NotAuthorizedToQueryWorkbasketException.class,
() ->
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("USER_2_1", "DOMAIN_A"))
.list());
ThrowingCallable call =
() -> {
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("USER_2_1", "DOMAIN_A"))
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class);
}
@WithAccessId(
@ -74,13 +75,14 @@ class QueryTasksByWorkbasketAccTest extends AbstractAccTest {
@Test
void testThrowsExceptionIfNoOpenerPermissionOnAtLeastOneQueriedWorkbasket() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
NotAuthorizedToQueryWorkbasketException.class,
() ->
taskService
.createTaskQuery()
.workbasketKeyDomainIn(
new KeyDomain("USER_1_1", "DOMAIN_A"), new KeyDomain("USER_2_1", "DOMAIN_A"))
.list());
ThrowingCallable call =
() -> {
taskService
.createTaskQuery()
.workbasketKeyDomainIn(
new KeyDomain("USER_1_1", "DOMAIN_A"), new KeyDomain("USER_2_1", "DOMAIN_A"))
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class);
}
}

31
lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithPaginationAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -33,7 +32,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(0, 10);
assertThat(results.size(), equalTo(10));
assertThat(results).hasSize(10);
}
@WithAccessId(
@ -47,7 +46,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(10, 10);
assertThat(results.size(), equalTo(10));
assertThat(results).hasSize(10);
}
@WithAccessId(
@ -63,7 +62,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(-1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// limit will be 0
results =
@ -71,7 +70,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// offset will be 0
results =
@ -79,7 +78,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.list(-1, 3);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -97,7 +96,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
// Getting full page
pageNumber = 4;
@ -107,7 +106,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(1));
assertThat(results).hasSize(1);
// Getting last results on 1 big page
pageNumber = 1;
@ -117,7 +116,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(22));
assertThat(results).hasSize(22);
// Getting last results on multiple pages
pageNumber = 3;
@ -127,7 +126,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(2));
assertThat(results).hasSize(2);
}
@WithAccessId(
@ -145,7 +144,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative size will be 0 = 0 results
pageNumber = 2;
@ -155,7 +154,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative page = first page
pageNumber = -1;
@ -165,7 +164,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(10));
assertThat(results).hasSize(10);
}
@WithAccessId(
@ -179,7 +178,7 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("GPK_KSC", "DOMAIN_A"))
.count();
assertThat(count, equalTo(22L));
assertThat(count).isEqualTo(22L);
}
@WithAccessId(
@ -189,6 +188,6 @@ class QueryTasksWithPaginationAccTest extends AbstractAccTest {
void testCountOfTaskQueryWithAttachmentChannelFilter() {
TaskService taskService = taskanaEngine.getTaskService();
long count = taskService.createTaskQuery().attachmentChannelIn("ch6").count();
assertThat(count, equalTo(2L));
assertThat(count).isEqualTo(2L);
}
}

117
lib/taskana-core/src/test/java/acceptance/task/QueryTasksWithSortingAccTest.java
View File

@ -1,16 +1,12 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static java.lang.String.CASE_INSENSITIVE_ORDER;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -47,11 +43,11 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByDomain(null)
.list();
assertThat(results.size(), equalTo(25));
assertThat(results).hasSize(25);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
if (previousSummary != null) {
assertFalse(previousSummary.getModified().isBefore(taskSummary.getModified()));
assertThat(previousSummary.getModified().isBefore(taskSummary.getModified())).isFalse();
}
previousSummary = taskSummary;
}
@ -71,7 +67,7 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.list();
// test is only valid with at least 2 results
Assertions.assertTrue(results.size() > 2);
assertThat(results).hasSizeGreaterThan(2);
List<String> idsDesc =
results.stream()
@ -80,7 +76,7 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.collect(Collectors.toList());
for (int i = 0; i < results.size(); i++) {
assertEquals(idsDesc.get(i), results.get(i).getId());
assertThat(results.get(i).getId()).isEqualTo(idsDesc.get(i));
}
}
@ -98,13 +94,13 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.list();
// test is only valid with at least 2 results
Assertions.assertTrue(results.size() > 2);
assertThat(results).hasSizeGreaterThan(2);
List<String> idsAsc =
results.stream().map(TaskSummary::getId).sorted().collect(Collectors.toList());
for (int i = 0; i < results.size(); i++) {
assertEquals(idsAsc.get(i), results.get(i).getId());
assertThat(results.get(i).getId()).isEqualTo(idsAsc.get(i));
}
}
@ -117,29 +113,17 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
List<TaskSummary> results =
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain("USER_3_2", "DOMAIN_B"))
.orderByDomain(asc)
.orderByName(asc)
.orderByCreated(null)
.list();
assertThat(results.size(), equalTo(25));
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
// System.out.println("domain: " + taskSummary.getDomain() + ", name: " +
// taskSummary.getName() + ",
// created: " + taskSummary.getCreated());
if (previousSummary != null) {
assertTrue(taskSummary.getDomain().compareToIgnoreCase(previousSummary.getDomain()) >= 0);
if (taskSummary.getDomain().equals(previousSummary.getDomain())) {
assertTrue(taskSummary.getName().compareToIgnoreCase(previousSummary.getName()) >= 0);
if (taskSummary.getName().equals(previousSummary.getName())) {
assertFalse(taskSummary.getCreated().isBefore(previousSummary.getCreated()));
}
}
}
previousSummary = taskSummary;
}
assertThat(results)
.hasSizeGreaterThan(2)
.isSortedAccordingTo(
Comparator.comparing(TaskSummary::getDomain, CASE_INSENSITIVE_ORDER)
.thenComparing(TaskSummary::getName, CASE_INSENSITIVE_ORDER)
.thenComparing(TaskSummary::getCreated));
}
@WithAccessId(
@ -158,16 +142,17 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByOwner(asc)
.list();
assertThat(results.size(), equalTo(25));
assertThat(results).hasSize(25);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
if (previousSummary != null) {
assertTrue(
taskSummary
.getPrimaryObjRef()
.getSystem()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystem())
<= 0);
assertThat(
taskSummary
.getPrimaryObjRef()
.getSystem()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystem())
<= 0)
.isTrue();
}
previousSummary = taskSummary;
}
@ -189,16 +174,17 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByState(asc)
.list();
assertThat(results.size(), equalTo(25));
assertThat(results).hasSize(25);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
if (previousSummary != null) {
assertTrue(
taskSummary
.getPrimaryObjRef()
.getSystemInstance()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystemInstance())
<= 0);
assertThat(
taskSummary
.getPrimaryObjRef()
.getSystemInstance()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getSystemInstance())
<= 0)
.isTrue();
}
previousSummary = taskSummary;
}
@ -218,19 +204,20 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByClaimed(asc)
.list();
assertThat(results.size(), equalTo(25));
assertThat(results).hasSize(25);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
// System.out.println("porCompany: " + taskSummary.getPrimaryObjRef().getCompany() + ",
// claimed: "
// + taskSummary.getClaimed());
if (previousSummary != null) {
assertTrue(
taskSummary
.getPrimaryObjRef()
.getCompany()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getCompany())
<= 0);
assertThat(
taskSummary
.getPrimaryObjRef()
.getCompany()
.compareToIgnoreCase(previousSummary.getPrimaryObjRef().getCompany())
<= 0)
.isTrue();
}
previousSummary = taskSummary;
}
@ -253,16 +240,17 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByCompleted(desc)
.list();
assertThat(results.size(), equalTo(22));
assertThat(results).hasSize(22);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
if (previousSummary != null) {
assertTrue(
taskSummary
.getWorkbasketSummary()
.getKey()
.compareToIgnoreCase(previousSummary.getWorkbasketSummary().getKey())
>= 0);
assertThat(
taskSummary
.getWorkbasketSummary()
.getKey()
.compareToIgnoreCase(previousSummary.getWorkbasketSummary().getKey())
>= 0)
.isTrue();
}
previousSummary = taskSummary;
}
@ -284,15 +272,16 @@ class QueryTasksWithSortingAccTest extends AbstractAccTest {
.orderByPrimaryObjectReferenceType(SortDirection.DESCENDING)
.list();
assertThat(results.size(), equalTo(22));
assertThat(results).hasSize(22);
TaskSummary previousSummary = null;
for (TaskSummary taskSummary : results) {
if (previousSummary != null) {
assertTrue(
taskSummary
.getBusinessProcessId()
.compareToIgnoreCase(previousSummary.getBusinessProcessId())
>= 0);
assertThat(
taskSummary
.getBusinessProcessId()
.compareToIgnoreCase(previousSummary.getBusinessProcessId())
>= 0)
.isTrue();
}
previousSummary = taskSummary;
}

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

@ -2,6 +2,7 @@ package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.util.IterableUtil.toArray;
import acceptance.AbstractAccTest;
import java.time.Duration;
@ -10,6 +11,7 @@ import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map.Entry;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -112,7 +114,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskService.setPlannedPropertyOfTasks(planned, taskIds);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(1);
assertThat(results.getErrorMap()).hasSize(1);
assertThat(results.getErrorForId("TKI:000000000000000000000000000047110059"))
.isInstanceOf(TaskNotFoundException.class);
Instant dueExpected = getInstant("2020-04-21T07:00:00");
@ -214,17 +216,18 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
String tkId2 = "TKI:000000000000000000000000000000000009";
String tkId3 = "TKI:000000000000000000000000000000000008";
String tkId4 = "TKI:000000000000000000000000000000000010";
List<String> taskIds = Arrays.asList(tkId1, tkId2, tkId3, tkId4);
Instant planned = getInstant("2020-02-25T07:00:00");
BulkOperationResults<String, TaskanaException> results =
taskService.setPlannedPropertyOfTasks(planned, taskIds);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(3);
assertThat(results.getErrorForId(tkId1)).isInstanceOf(NotAuthorizedException.class);
assertThat(results.getErrorForId(tkId2)).isInstanceOf(NotAuthorizedException.class);
assertThat(results.getErrorForId(tkId3)).isInstanceOf(NotAuthorizedException.class);
assertThat(results.getErrorForId(tkId4)).isInstanceOf(NotAuthorizedException.class);
assertThat(results.getErrorMap())
.hasSize(3)
.containsKeys(toArray(taskIds))
.extractingFromEntries(Entry::getValue)
.hasOnlyElementsOfType(NotAuthorizedException.class);
}
@WithAccessId(

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

@ -7,8 +7,11 @@ import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import org.assertj.core.api.Condition;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -62,9 +65,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testSetOwnerViaUpdateTaskNotAuthorized()
throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
InvalidOwnerException {
void testSetOwnerViaUpdateTaskNotAuthorized() {
TaskService taskService = taskanaEngine.getTaskService();
String taskReadyId = "TKI:000000000000000000000000000000000024";
@ -80,9 +81,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testSetOwnerOfClaimedTaskFails()
throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
InvalidOwnerException {
void testSetOwnerOfClaimedTaskFails() throws TaskNotFoundException, NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService();
String taskClaimedId = "TKI:000000000000000000000000000000000026";
@ -98,9 +97,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testSetOwnerNotAuthorized()
throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
InvalidOwnerException {
void testSetOwnerNotAuthorized() {
TaskService taskService = taskanaEngine.getTaskService();
String taskReadyId = "TKI:000000000000000000000000000000000024";
@ -109,7 +106,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
assertThatThrownBy(() -> taskService.getTask(taskReadyId))
.isInstanceOf(NotAuthorizedException.class);
BulkOperationResults<String, TaskanaException> results =
taskService.setOwnerOfTasks(anyUserName, Arrays.asList(taskReadyId));
taskService.setOwnerOfTasks(anyUserName, Collections.singletonList(taskReadyId));
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorForId(taskReadyId)).isInstanceOf(NotAuthorizedException.class);
}
@ -146,7 +143,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(1);
assertThat(results.getErrorMap()).hasSize(1);
assertThat(results.getErrorForId("TKI:000000000000000000000000000047110059"))
.isInstanceOf(TaskNotFoundException.class);
}
@ -166,7 +163,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("someUser", taskIds);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(3);
assertThat(results.getErrorMap()).hasSize(3);
}
@WithAccessId(
@ -190,68 +187,46 @@ public class SetOwnerAccTest extends AbstractAccTest {
List<TaskSummary> allTaskSummaries =
new TaskanaEngineProxyForTest(taskanaEngine)
.getEngine()
.runAsAdmin(
() -> {
return taskanaEngine.getTaskService().createTaskQuery().list();
});
.runAsAdmin(() -> taskanaEngine.getTaskService().createTaskQuery().list());
List<String> allTaskIds =
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
assertThat(allTaskSummaries.size()).isEqualTo(83);
assertThat(allTaskSummaries).hasSize(83);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(58);
long numberOfInvalidStateExceptions =
results.getErrorMap().entrySet().stream()
.filter(
e ->
e.getValue()
.getClass()
.getName()
.equals(InvalidStateException.class.getCanonicalName()))
.count();
assertThat(numberOfInvalidStateExceptions).isEqualTo(35);
long numberOfNotAuthorizedExceptions =
results.getErrorMap().entrySet().stream()
.filter(
e ->
e.getValue()
.getClass()
.getName()
.equals(NotAuthorizedException.class.getCanonicalName()))
.count();
assertThat(numberOfNotAuthorizedExceptions).isEqualTo(23);
Condition<Object> invalidStateException =
new Condition<>(c -> c.getClass() == InvalidStateException.class, "InvalidStateException");
Condition<Object> notAuthorizedException =
new Condition<>(
c -> c.getClass() == NotAuthorizedException.class, "NotAuthorizedException");
assertThat(results.getErrorMap())
.hasSize(58)
.extractingFromEntries(Entry::getValue)
.hasOnlyElementsOfTypes(InvalidStateException.class, NotAuthorizedException.class)
.areExactly(35, invalidStateException)
.areExactly(23, notAuthorizedException);
}
@WithAccessId(
userName = "admin",
groupNames = {"group_2"})
@Test
void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin()
throws NoSuchFieldException, IllegalAccessException, SQLException {
void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin() throws SQLException {
resetDb(false);
List<TaskSummary> allTaskSummaries = taskanaEngine.getTaskService().createTaskQuery().list();
List<String> allTaskIds =
allTaskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toList());
BulkOperationResults<String, TaskanaException> results =
taskanaEngine.getTaskService().setOwnerOfTasks("theWorkaholic", allTaskIds);
assertThat(allTaskSummaries.size()).isEqualTo(83);
assertThat(allTaskSummaries).hasSize(83);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().size()).isEqualTo(36);
long numberOfInvalidStateExceptions =
results.getErrorMap().entrySet().stream()
.filter(
e ->
e.getValue()
.getClass()
.getName()
.equals(InvalidStateException.class.getCanonicalName()))
.count();
assertThat(numberOfInvalidStateExceptions).isEqualTo(36);
assertThat(results.getErrorMap())
.hasSize(36)
.extractingFromEntries(Entry::getValue)
.hasOnlyElementsOfType(InvalidStateException.class);
}
private Task setOwner(String taskReadyId, String anyUserName)
throws TaskNotFoundException, NotAuthorizedException, ClassificationNotFoundException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,

43
lib/taskana-core/src/test/java/acceptance/task/TerminateTaskAccTest.java
View File

@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -22,10 +23,10 @@ import pro.taskana.task.api.models.TaskSummary;
/** Acceptance tests for all claim and complete scenarios. */
@ExtendWith(JaasExtension.class)
class TerminateTaskAccTest extends AbstractAccTest {
private TaskService taskService;
private static TaskService taskService;
TerminateTaskAccTest() {
super();
@BeforeAll
static void setup() {
taskService = taskanaEngine.getTaskService();
}
@ -41,7 +42,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
void testQueryTerminatedTasks() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.TERMINATED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
assertThat(taskSummaries).hasSize(5);
}
@WithAccessId(
@ -51,7 +52,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
void testTerminateReadyTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
List<TaskSummary> taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list();
assertThat(taskSummaries.size()).isEqualTo(47);
assertThat(taskSummaries).hasSize(47);
taskService.terminateTask(taskSummaries.get(0).getId());
long numTasks = taskService.createTaskQuery().stateIn(TaskState.READY).count();
assertThat(numTasks).isEqualTo(46);
@ -67,7 +68,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();
assertThat(taskSummaries.size()).isEqualTo(16);
assertThat(taskSummaries).hasSize(16);
long numTasksTerminated = taskService.createTaskQuery().stateIn(TaskState.TERMINATED).count();
assertThat(numTasksTerminated).isEqualTo(5);
@ -83,15 +84,11 @@ class TerminateTaskAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testTerminateCompletedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testTerminateCompletedTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.COMPLETED).list();
assertThat(taskSummaries.size()).isEqualTo(6);
ThrowingCallable taskanaCall =
() -> {
taskService.terminateTask(taskSummaries.get(0).getId());
};
assertThat(taskSummaries).hasSize(6);
ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
@ -100,15 +97,11 @@ class TerminateTaskAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testTerminateTerminatedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testTerminateTerminatedTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.TERMINATED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
ThrowingCallable taskanaCall =
() -> {
taskService.terminateTask(taskSummaries.get(0).getId());
};
assertThat(taskSummaries).hasSize(5);
ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
@ -117,15 +110,11 @@ class TerminateTaskAccTest extends AbstractAccTest {
userName = "user_1_2",
groupNames = {"group_1"})
@Test
void testTerminateCancelledTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testTerminateCancelledTask() {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CANCELLED).list();
assertThat(taskSummaries.size()).isEqualTo(5);
ThrowingCallable taskanaCall =
() -> {
taskService.terminateTask(taskSummaries.get(0).getId());
};
assertThat(taskSummaries).hasSize(5);
ThrowingCallable taskanaCall = () -> taskService.terminateTask(taskSummaries.get(0).getId());
assertThatThrownBy(taskanaCall).isInstanceOf(InvalidStateException.class);
}
}

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

@ -1,12 +1,7 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Instant;
@ -14,7 +9,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -56,10 +51,10 @@ class TransferTaskAccTest extends AbstractAccTest {
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
}
@WithAccessId(
@ -77,10 +72,10 @@ class TransferTaskAccTest extends AbstractAccTest {
taskService.transfer(task.getId(), "USER_1_1", "DOMAIN_A");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
}
@WithAccessId(
@ -96,8 +91,8 @@ class TransferTaskAccTest extends AbstractAccTest {
Task transferedTask = taskService.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
assertNotNull(transferedTask);
assertNotEquals(domain1, transferedTask.getDomain());
assertThat(transferedTask).isNotNull();
assertThat(transferedTask.getDomain()).isNotEqualTo(domain1);
}
@WithAccessId(
@ -109,9 +104,11 @@ class TransferTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005"));
ThrowingCallable call =
() -> {
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -126,8 +123,11 @@ class TransferTaskAccTest extends AbstractAccTest {
taskService.claim(task.getId());
taskService.setTaskRead(task.getId(), true);
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> taskService.transfer(task.getId(), "INVALID"));
ThrowingCallable call =
() -> {
taskService.transfer(task.getId(), "INVALID");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@WithAccessId(
@ -137,9 +137,11 @@ class TransferTaskAccTest extends AbstractAccTest {
void testTransferTaskDoesNotExist() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskService.transfer("Invalid", "WBI:100000000000000000000000000000000006"));
ThrowingCallable call =
() -> {
taskService.transfer("Invalid", "WBI:100000000000000000000000000000000006");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -149,12 +151,13 @@ class TransferTaskAccTest extends AbstractAccTest {
void testTransferNotAuthorizationOnWorkbasketTransfer() {
TaskService taskService = taskanaEngine.getTaskService();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
taskService.transfer(
"TKI:200000000000000000000000000000000007",
"WBI:100000000000000000000000000000000006"));
ThrowingCallable call =
() -> {
taskService.transfer(
"TKI:200000000000000000000000000000000007",
"WBI:100000000000000000000000000000000006");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -166,9 +169,11 @@ class TransferTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
Assertions.assertThrows(
InvalidStateException.class,
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005"));
ThrowingCallable call =
() -> {
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(
@ -180,9 +185,11 @@ class TransferTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000008"));
ThrowingCallable call =
() -> {
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -200,28 +207,28 @@ class TransferTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
assertFalse(results.containsErrors());
assertThat(results.containsErrors()).isFalse();
final Workbasket wb =
taskanaEngine.getWorkbasketService().getWorkbasket("USER_1_1", "DOMAIN_A");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000004");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask.getWorkbasketKey(), equalTo(wb.getKey()));
assertThat(transferredTask.getDomain(), equalTo(wb.getDomain()));
assertFalse(transferredTask.getModified().isBefore(before));
assertThat(transferredTask.getOwner(), equalTo(null));
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
assertThat(transferredTask.getWorkbasketKey()).isEqualTo(wb.getKey());
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000005");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask.getWorkbasketKey(), equalTo(wb.getKey()));
assertThat(transferredTask.getDomain(), equalTo(wb.getDomain()));
assertFalse(transferredTask.getModified().isBefore(before));
assertThat(transferredTask.getOwner(), equalTo(null));
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
assertThat(transferredTask.getWorkbasketKey()).isEqualTo(wb.getKey());
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
}
@WithAccessId(
@ -247,47 +254,43 @@ class TransferTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
// check for exceptions in bulk
assertTrue(results.containsErrors());
assertThat(results.getErrorMap().values().size(), equalTo(5));
assertEquals(
results.getErrorForId("TKI:000000000000000000000000000000000041").getClass(),
NotAuthorizedException.class);
assertEquals(
results.getErrorForId("TKI:200000000000000000000000000000000006").getClass(),
InvalidStateException.class);
assertEquals(results.getErrorForId("").getClass(), InvalidArgumentException.class);
assertEquals(
results.getErrorForId("TKI:000000000000000000000000000000000099").getClass(),
TaskNotFoundException.class);
assertEquals(
results.getErrorForId("TKI:100000000000000000000000000000000006").getClass(),
InvalidStateException.class);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap().values()).hasSize(5);
assertThat(results.getErrorForId("TKI:000000000000000000000000000000000041").getClass())
.isEqualTo(NotAuthorizedException.class);
assertThat(results.getErrorForId("TKI:200000000000000000000000000000000006").getClass())
.isEqualTo(InvalidStateException.class);
assertThat(InvalidArgumentException.class).isEqualTo(results.getErrorForId("").getClass());
assertThat(results.getErrorForId("TKI:000000000000000000000000000000000099").getClass())
.isEqualTo(TaskNotFoundException.class);
assertThat(results.getErrorForId("TKI:100000000000000000000000000000000006").getClass())
.isEqualTo(InvalidStateException.class);
// verify valid requests
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000006");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask.getWorkbasketKey(), equalTo(wb.getKey()));
assertThat(transferredTask.getDomain(), equalTo(wb.getDomain()));
assertFalse(transferredTask.getModified().isBefore(before));
assertThat(transferredTask.getOwner(), equalTo(null));
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
assertThat(transferredTask.getWorkbasketKey()).isEqualTo(wb.getKey());
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000002");
assertNotNull(transferredTask);
assertFalse(transferredTask.isTransferred());
assertEquals("USER_1_1", transferredTask.getWorkbasketKey());
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("USER_1_1");
transferredTask = taskService.getTask("TKI:200000000000000000000000000000000006");
assertNotNull(transferredTask);
assertFalse(transferredTask.isTransferred());
assertEquals("TEAMLEAD_2", transferredTask.getWorkbasketKey());
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TEAMLEAD_2");
transferredTask = taskService.getTask("TKI:100000000000000000000000000000000006");
assertNotNull(transferredTask);
assertFalse(transferredTask.isTransferred());
assertEquals("TEAMLEAD_1", transferredTask.getWorkbasketKey());
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isFalse();
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TEAMLEAD_1");
}
@WithAccessId(userName = "teamlead_1")
@ -298,13 +301,13 @@ class TransferTaskAccTest extends AbstractAccTest {
taskIdList.add("TKI:000000000000000000000000000000000006"); // working
taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
Throwable t =
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
taskService.transferTasks("WBI:100000000000000000000000000000000010", taskIdList));
assertTrue(t.getMessage().contains("APPEND"));
ThrowingCallable call =
() -> {
taskService.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
};
assertThatThrownBy(call)
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("APPEND");
}
@WithAccessId(
@ -326,20 +329,23 @@ class TransferTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
// test with invalid list
Throwable t =
Assertions.assertThrows(
InvalidArgumentException.class,
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", null));
assertEquals(t.getMessage(), "TaskIds must not be null.");
ThrowingCallable call =
() -> {
taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
};
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("TaskIds must not be null.");
// test with list containing only invalid arguments
Throwable t2 =
Assertions.assertThrows(
InvalidArgumentException.class,
() ->
taskService.transferTasks(
"WBI:100000000000000000000000000000000006", Arrays.asList("", "", "", null)));
assertEquals(t2.getMessage(), "TaskIds must not contain only invalid arguments.");
call =
() -> {
taskService.transferTasks(
"WBI:100000000000000000000000000000000006", Arrays.asList("", "", "", null));
};
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("TaskIds must not contain only invalid arguments.");
}
@WithAccessId(
@ -349,9 +355,11 @@ class TransferTaskAccTest extends AbstractAccTest {
void testThrowsExceptionIfEmptyListIsSupplied() {
TaskService taskService = taskanaEngine.getTaskService();
List<String> taskIds = new ArrayList<>();
Assertions.assertThrows(
InvalidArgumentException.class,
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds));
ThrowingCallable call =
() -> {
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(
@ -370,27 +378,27 @@ class TransferTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results =
taskService.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
assertFalse(results.containsErrors());
assertThat(results.containsErrors()).isFalse();
final Workbasket wb =
taskanaEngine.getWorkbasketService().getWorkbasket("GPK_B_KSC_1", "DOMAIN_B");
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000023");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask.getWorkbasketKey(), equalTo(wb.getKey()));
assertThat(transferredTask.getDomain(), equalTo(wb.getDomain()));
assertFalse(transferredTask.getModified().isBefore(before));
assertThat(transferredTask.getOwner(), equalTo(null));
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
assertThat(transferredTask.getWorkbasketKey()).isEqualTo(wb.getKey());
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000024");
assertNotNull(transferredTask);
assertTrue(transferredTask.isTransferred());
assertFalse(transferredTask.isRead());
assertEquals(TaskState.READY, transferredTask.getState());
assertThat(transferredTask.getWorkbasketKey(), equalTo(wb.getKey()));
assertThat(transferredTask.getDomain(), equalTo(wb.getDomain()));
assertFalse(transferredTask.getModified().isBefore(before));
assertThat(transferredTask.getOwner(), equalTo(null));
assertThat(transferredTask).isNotNull();
assertThat(transferredTask.isTransferred()).isTrue();
assertThat(transferredTask.isRead()).isFalse();
assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
assertThat(transferredTask.getWorkbasketKey()).isEqualTo(wb.getKey());
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
assertThat(transferredTask.getOwner()).isNull();
}
}

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

@ -1,19 +1,16 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.assertj.core.api.Assertions.fail;
import acceptance.AbstractAccTest;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -33,6 +30,7 @@ import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.AttachmentSummary;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.models.AttachmentImpl;
import pro.taskana.task.internal.models.TaskImpl;
@ -49,8 +47,32 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
private Attachment attachment;
private TaskService taskService;
UpdateTaskAttachmentsAccTest() {
super();
@BeforeEach
@WithAccessId(userName = "admin")
void setUp()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
taskService = taskanaEngine.getTaskService();
task =
taskService.getTask(
"TKI:000000000000000000000000000000000000"); // class T2000, prio 1, SL P1D
task.setClassificationKey("T2000");
attachment =
createAttachment(
"DOCTYPE_DEFAULT", // prio 99, SL P2000D
createObjectReference(
"COMPANY_A",
"SYSTEM_B",
"INSTANCE_B",
"ArchiveId",
"12345678901234567890123456789012345678901234567890"),
"E-MAIL",
"2018-01-15",
createSimpleCustomProperties(3));
task.getAttachments().clear();
taskService.updateTask(task);
assertThat(task).isNotNull();
}
@WithAccessId(
@ -61,33 +83,18 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
final int attachmentCount = task.getAttachments().size();
assertEquals(1, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
task.addAttachment(attachment);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount + 1));
assertThat(
task.getAttachments().get(0).getClassificationSummary().getKey(),
equalTo("DOCTYPE_DEFAULT"));
assertThat(
task.getAttachments().get(0).getObjectReference().getCompany(), equalTo("COMPANY_A"));
assertThat(task.getAttachments().get(0).getObjectReference().getSystem(), equalTo("SYSTEM_B"));
assertThat(
task.getAttachments().get(0).getObjectReference().getSystemInstance(),
equalTo("INSTANCE_B"));
assertThat(task.getAttachments().get(0).getObjectReference().getType(), equalTo("ArchiveId"));
assertThat(
task.getAttachments().get(0).getObjectReference().getValue(),
equalTo("12345678901234567890123456789012345678901234567890"));
assertEquals(99, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
task.getAttachments().forEach(at -> assertEquals(at.getModified(), task.getModified()));
assertThat(task.getAttachments())
.hasSize(attachmentCount + 1)
.contains(attachment)
.extracting(Attachment::getModified)
.containsOnly(task.getModified());
}
@WithAccessId(
@ -98,11 +105,10 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
task.getAttachments().clear();
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertEquals(0, task.getAttachments().size());
assertThat(task.getAttachments()).isEmpty();
AttachmentImpl attachment = (AttachmentImpl) this.attachment;
attachment.setId("TAI:000017");
@ -110,8 +116,10 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.addAttachment(attachment);
task = taskService.updateTask(task);
assertEquals(1, task.getAttachments().size());
task.getAttachments().forEach(at -> assertEquals(at.getModified(), task.getModified()));
assertThat(task.getAttachments())
.hasSize(1)
.extracting(AttachmentSummary::getModified)
.containsOnly(task.getModified());
}
@WithAccessId(
@ -122,20 +130,18 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
final int attachmentCount = 0;
task.getAttachments().clear();
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount));
assertThat(task.getAttachments()).hasSize(attachmentCount);
AttachmentImpl attachment = (AttachmentImpl) this.attachment;
attachment.setId("TAI:000017");
task.getAttachments().add(attachment);
task.getAttachments().add(attachment);
task.getAttachments().add(attachment);
Assertions.assertThrows(
AttachmentPersistenceException.class, () -> task = taskService.updateTask(task));
ThrowingCallable call = () -> taskService.updateTask(task);
assertThatThrownBy(call).isInstanceOf(AttachmentPersistenceException.class);
}
@WithAccessId(
@ -146,14 +152,13 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
// Add attachment before
task = taskService.getTask(task.getId());
final int attachmentCount = task.getAttachments().size();
task.addAttachment(attachment);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount + 1));
assertThat(task.getAttachments()).hasSize(attachmentCount + 1);
// Change sth. and add same (id) again - override/update
String newChannel = "UPDATED EXTERNAL SINCE LAST ADD";
@ -168,13 +173,13 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.addAttachment(updatedAttachment);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount2));
assertThat(task.getAttachments().get(0).getChannel(), equalTo(newChannel));
assertEquals(999, task.getPriority());
assertThat(task.getAttachments()).hasSize(attachmentCount2);
assertThat(task.getAttachments().get(0).getChannel()).isEqualTo(newChannel);
assertThat(task.getPriority()).isEqualTo(999);
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(task.getDue(), 1);
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(task.getPlanned().plus(Duration.ofDays(calendarDays))).isEqualTo(task.getDue());
}
@WithAccessId(
@ -185,7 +190,6 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
// Add Attachment before
final int attachmentCount = task.getAttachments().size();
((AttachmentImpl) attachment).setId("TAI:0001");
@ -194,14 +198,14 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.addAttachment(attachment); // overwrite, same id
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount + 1));
assertThat(task.getAttachments()).hasSize(attachmentCount + 1);
// Add same again - ignored
final int attachmentCount2 = task.getAttachments().size();
Attachment redundantAttachment = task.getAttachments().get(0);
task.addAttachment(redundantAttachment);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(attachmentCount2));
assertThat(task.getAttachments()).hasSize(attachmentCount2);
}
@WithAccessId(
@ -212,21 +216,19 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
// Try to add a single NULL-Element
final int attachmentCount = task.getAttachments().size();
task.addAttachment(null);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount));
assertThat(task.getAttachments()).hasSize(attachmentCount);
// Try to set the Attachments to NULL and update it
((TaskImpl) task).setAttachments(null);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(attachmentCount)); // locally, not persisted
assertThat(task.getAttachments()).hasSize(attachmentCount); // locally, not persisted
task = taskService.getTask(task.getId());
assertThat(
task.getAttachments().size(), equalTo(attachmentCount)); // persisted values not changed
assertThat(task.getAttachments()).hasSize(attachmentCount); // persisted values not changed
// Test no NullPointer on NULL-Value and removing it on current data.
// New loading can do this, but returned value should got this "function", too.
@ -235,12 +237,11 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.getAttachments().add(null);
task.getAttachments().add(null);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(attachmentCount2)); // locally, not persisted
assertThat(task.getAttachments()).hasSize(attachmentCount2); // locally, not persisted
task = taskService.getTask(task.getId());
assertThat(
task.getAttachments().size(), equalTo(attachmentCount2)); // persisted values not changed
assertEquals(1, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getAttachments()).hasSize(attachmentCount2); // persisted values not changed
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
}
@WithAccessId(
@ -251,23 +252,20 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
task.addAttachment(attachment);
task = taskService.updateTask(task);
assertEquals(99, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getPriority()).isEqualTo(99);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
int attachmentCount = task.getAttachments().size();
Attachment attachmentToRemove = task.getAttachments().get(0);
task.removeAttachment(attachmentToRemove.getId());
task = taskService.updateTask(task);
assertThat(
task.getAttachments().size(),
equalTo(attachmentCount - 1)); // locally, removed and not persisted
assertThat(task.getAttachments())
.hasSize(attachmentCount - 1); // locally, removed and not persisted
task = taskService.getTask(task.getId());
assertThat(
task.getAttachments().size(), equalTo(attachmentCount - 1)); // persisted, values removed
assertEquals(1, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getAttachments()).hasSize(attachmentCount - 1); // persisted, values removed
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
}
@WithAccessId(
@ -278,22 +276,21 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
task.addAttachment(attachment);
task = taskService.updateTask(task);
int attachmentCount = task.getAttachments().size();
task.removeAttachment(null);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(attachmentCount)); // locally, nothing changed
assertThat(task.getAttachments()).hasSize(attachmentCount); // locally, nothing changed
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount)); // persisted, still same
assertThat(task.getAttachments()).hasSize(attachmentCount); // persisted, still same
task.removeAttachment("INVALID ID HERE");
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(attachmentCount)); // locally, nothing changed
assertThat(task.getAttachments()).hasSize(attachmentCount); // locally, nothing changed
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount)); // persisted, still same
assertThat(task.getAttachments()).hasSize(attachmentCount); // persisted, still same
}
@WithAccessId(
@ -304,17 +301,16 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
((TaskImpl) task).setAttachments(new ArrayList<>());
task = taskService.updateTask(task);
assertEquals(1, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
Attachment attachment = this.attachment;
task.addAttachment(attachment);
task = taskService.updateTask(task);
assertEquals(99, task.getPriority());
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(1)));
assertThat(task.getPriority()).isEqualTo(99);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
final int attachmentCount = task.getAttachments().size();
@ -327,13 +323,13 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.getAttachments().get(0).setClassificationSummary(newClassification.asSummary());
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(attachmentCount));
assertThat(task.getAttachments().get(0).getChannel(), equalTo(newChannel));
assertEquals(999, task.getPriority());
assertThat(task.getAttachments()).hasSize(attachmentCount);
assertThat(task.getAttachments().get(0).getChannel()).isEqualTo(newChannel);
assertThat(task.getPriority()).isEqualTo(999);
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(task.getDue(), 1);
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(task.getPlanned().plus(Duration.ofDays(calendarDays))).isEqualTo(task.getDue());
}
@WithAccessId(
@ -344,9 +340,8 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
// setup test
assertThat(task.getAttachments().size(), equalTo(0));
assertThat(task.getAttachments()).isEmpty();
task.addAttachment(attachment);
Attachment attachment2 =
@ -364,13 +359,13 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.addAttachment(attachment2);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertEquals(101, task.getPriority());
assertThat(task.getPriority()).isEqualTo(101);
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(task.getDue(), 1);
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(task.getPlanned().plus(Duration.ofDays(calendarDays))).isEqualTo(task.getDue());
assertThat(task.getAttachments().size(), equalTo(2));
assertThat(task.getAttachments()).hasSize(2);
List<Attachment> attachments = task.getAttachments();
boolean rohrpostFound = false;
boolean emailFound = false;
@ -379,17 +374,18 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
int custAttSize = att.getCustomAttributes().size();
if ("ROHRPOST".equals(channel)) {
rohrpostFound = true;
assertEquals(att.getModified(), task.getModified());
assertThat(task.getModified()).isEqualTo(att.getModified());
} else if ("E-MAIL".equals(channel)) {
emailFound = true;
} else {
fail("unexpected attachment detected " + att);
}
assertTrue(
("ROHRPOST".equals(channel) && custAttSize == 4)
|| ("E-MAIL".equals(channel) && custAttSize == 3));
assertThat(
("ROHRPOST".equals(channel) && custAttSize == 4)
|| ("E-MAIL".equals(channel) && custAttSize == 3))
.isTrue();
}
assertTrue(rohrpostFound && emailFound);
assertThat(rohrpostFound && emailFound).isTrue();
ClassificationSummary newClassificationSummary =
taskanaEngine
@ -407,11 +403,11 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.setClassificationKey("DOCTYPE_DEFAULT"); // Prio 99, SL P2000D
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertEquals(99, task.getPriority());
assertThat(task.getPriority()).isEqualTo(99);
calendarDays = converter.convertWorkingDaysToDays(task.getDue(), 16);
assertEquals(task.getDue(), task.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(task.getPlanned().plus(Duration.ofDays(calendarDays))).isEqualTo(task.getDue());
rohrpostFound = false;
boolean faxFound = false;
@ -427,11 +423,12 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
fail("unexpected attachment detected " + att);
}
assertTrue(
("ROHRPOST".equals(channel) && custAttSize == 4)
|| ("FAX".equals(channel) && custAttSize == 3));
assertThat(
("ROHRPOST".equals(channel) && custAttSize == 4)
|| ("FAX".equals(channel) && custAttSize == 3))
.isTrue();
}
assertTrue(faxFound && rohrpostFound);
assertThat(faxFound && rohrpostFound).isTrue();
}
@WithAccessId(
@ -442,9 +439,8 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
setUpMethod();
// setup test
assertThat(task.getAttachments().size(), equalTo(0));
assertThat(task.getAttachments()).isEmpty();
task.addAttachment(attachment);
Attachment attachment2 =
createAttachment(
@ -461,10 +457,9 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.addAttachment(attachment2);
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
assertThat(task.getAttachments().size(), equalTo(2));
assertThat(
task.getAttachments().get(0).getClassificationSummary().getKey(),
equalTo("DOCTYPE_DEFAULT"));
assertThat(task.getAttachments()).hasSize(2);
assertThat(task.getAttachments().get(0).getClassificationSummary().getKey())
.isEqualTo("DOCTYPE_DEFAULT");
Attachment attachment3 =
createAttachment(
@ -483,20 +478,20 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
task.getAttachments().clear();
task.addAttachment(attachment3);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(1));
assertThat(task.getAttachments().get(0).getChannel(), equalTo("DHL"));
task.getAttachments().forEach(at -> assertEquals(at.getModified(), task.getModified()));
assertThat(task.getAttachments()).hasSize(1);
assertThat(task.getAttachments().get(0).getChannel()).isEqualTo("DHL");
task.getAttachments().forEach(at -> assertThat(task.getModified()).isEqualTo(at.getModified()));
// setup environment for 2nd version of replacement (list.add call)
task.getAttachments().add(attachment2);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(2));
assertThat(task.getAttachments().get(1).getChannel(), equalTo("E-MAIL"));
assertThat(task.getAttachments()).hasSize(2);
assertThat(task.getAttachments().get(1).getChannel()).isEqualTo("E-MAIL");
// replace attachments
task.getAttachments().clear();
task.getAttachments().add(attachment3);
task = taskService.updateTask(task);
assertThat(task.getAttachments().size(), equalTo(1));
assertThat(task.getAttachments().get(0).getChannel(), equalTo("DHL"));
assertThat(task.getAttachments()).hasSize(1);
assertThat(task.getAttachments().get(0).getChannel()).isEqualTo("DHL");
}
@WithAccessId(
@ -508,7 +503,6 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
ConcurrencyException, AttachmentPersistenceException, InvalidStateException {
setUpMethod();
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010"); // prio 8, SL P7D
@ -541,30 +535,29 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
createSimpleCustomProperties(3)));
Task createdTask = taskService.createTask(newTask);
assertNotNull(createdTask.getId());
assertThat(createdTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertThat(createdTask.getId()).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
createdTask
.getAttachments()
.forEach(at -> assertEquals(at.getModified(), createdTask.getModified()));
.forEach(at -> assertThat(createdTask.getModified()).isEqualTo(at.getModified()));
Task readTask = taskService.getTask(createdTask.getId());
assertNotNull(readTask);
assertThat(readTask.getCreator(), equalTo(CurrentUserContext.getUserid()));
assertNotNull(readTask.getAttachments());
assertEquals(2, readTask.getAttachments().size());
assertNotNull(readTask.getAttachments().get(1).getCreated());
assertNotNull(readTask.getAttachments().get(1).getModified());
assertEquals(
readTask.getAttachments().get(0).getCreated(),
readTask.getAttachments().get(1).getModified());
// assertNotNull(readTask.getAttachments().get(0).getClassification());
assertNotNull(readTask.getAttachments().get(0).getObjectReference());
assertThat(readTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
assertThat(readTask.getAttachments()).isNotNull();
assertThat(readTask.getAttachments()).hasSize(2);
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
assertThat(readTask.getAttachments().get(0).getCreated())
.isEqualTo(readTask.getAttachments().get(1).getModified());
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
assertEquals(99, readTask.getPriority());
assertThat(readTask.getPriority()).isEqualTo(99);
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(Instant.now());
long calendarDays = converter.convertWorkingDaysToDays(readTask.getPlanned(), 1);
assertEquals(readTask.getDue(), readTask.getPlanned().plus(Duration.ofDays(calendarDays)));
assertThat(readTask.getPlanned().plus(Duration.ofDays(calendarDays)))
.isEqualTo(readTask.getDue());
}
@WithAccessId(
@ -601,38 +594,8 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
.filter(a -> attachment.getId().equals(a.getId()))
.findFirst()
.orElse(null);
assertNotNull(updatedAttachment);
assertEquals(updatedAttachment.getModified(),updatedTask.getModified());
assertEquals("TEST_VALUE", updatedAttachment.getCustomAttributes().get("TEST_KEY"));
}
// this method needs to run with access ids, otherwise getTask throws NotAuthorizedException
// since only @Test and not @Before methods are run by JAASRunner, we call this method explicitely
// at
// the begin of each testcase....
private void setUpMethod()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
taskService = taskanaEngine.getTaskService();
task =
taskService.getTask(
"TKI:000000000000000000000000000000000000"); // class T2000, prio 1, SL P1D
task.setClassificationKey("T2000");
attachment =
createAttachment(
"DOCTYPE_DEFAULT", // prio 99, SL P2000D
createObjectReference(
"COMPANY_A",
"SYSTEM_B",
"INSTANCE_B",
"ArchiveId",
"12345678901234567890123456789012345678901234567890"),
"E-MAIL",
"2018-01-15",
createSimpleCustomProperties(3));
task.getAttachments().clear();
taskService.updateTask(task);
assertThat(task, not(equalTo(null)));
assertThat(updatedAttachment).isNotNull();
assertThat(updatedTask.getModified()).isEqualTo(updatedAttachment.getModified());
assertThat(updatedAttachment.getCustomAttributes().get("TEST_KEY")).isEqualTo("TEST_VALUE");
}
}

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

@ -1,20 +1,14 @@
package acceptance.task;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -52,13 +46,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.claim(task.getId());
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000025");
assertNotNull(claimedTask);
assertEquals(TaskState.CLAIMED, claimedTask.getState());
assertNotNull(claimedTask.getClaimed());
assertNotEquals(claimedTask.getCreated(), claimedTask.getModified());
assertEquals(claimedTask.getClaimed(), claimedTask.getModified());
assertTrue(claimedTask.isRead());
assertEquals("user_1_2", claimedTask.getOwner());
assertThat(claimedTask).isNotNull();
assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
assertThat(claimedTask.getClaimed()).isNotNull();
assertThat(claimedTask.getModified()).isNotEqualTo(claimedTask.getCreated());
assertThat(claimedTask.getModified()).isEqualTo(claimedTask.getClaimed());
assertThat(claimedTask.isRead()).isTrue();
assertThat(claimedTask.getOwner()).isEqualTo("user_1_2");
}
@WithAccessId(
@ -70,7 +64,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000026");
Assertions.assertThrows(InvalidOwnerException.class, () -> taskService.claim(task.getId()));
// Assertions.assertThrows(InvalidOwnerException.class, () ->
// taskService.claim(task.getId()));
ThrowingCallable call =
() -> {
taskService.claim(task.getId());
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -95,7 +95,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000028");
Assertions.assertThrows(InvalidOwnerException.class, () -> taskService.claim(task.getId()));
// Assertions.assertThrows(InvalidOwnerException.class, () ->
// taskService.claim(task.getId()));
ThrowingCallable call =
() -> {
taskService.claim(task.getId());
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -111,11 +117,11 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.cancelClaim(claimedTask.getId());
Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
assertNotNull(unclaimedTask);
assertEquals(TaskState.READY, unclaimedTask.getState());
assertNull(unclaimedTask.getClaimed());
assertTrue(unclaimedTask.isRead());
assertNull(unclaimedTask.getOwner());
assertThat(unclaimedTask).isNotNull();
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
assertThat(unclaimedTask.getClaimed()).isNull();
assertThat(unclaimedTask.isRead()).isTrue();
assertThat(unclaimedTask.getOwner()).isNull();
}
@WithAccessId(
@ -127,8 +133,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
Assertions.assertThrows(
InvalidOwnerException.class, () -> taskService.cancelClaim(claimedTask.getId()));
// Assertions.assertThrows(
// InvalidOwnerException.class, () -> taskService.cancelClaim(claimedTask.getId()));
ThrowingCallable call =
() -> {
taskService.cancelClaim(claimedTask.getId());
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -144,11 +155,11 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.forceCancelClaim(claimedTask.getId());
Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
assertNotNull(unclaimedTask);
assertEquals(TaskState.READY, unclaimedTask.getState());
assertNull(unclaimedTask.getClaimed());
assertTrue(unclaimedTask.isRead());
assertNull(unclaimedTask.getOwner());
assertThat(unclaimedTask).isNotNull();
assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
assertThat(unclaimedTask.getClaimed()).isNull();
assertThat(unclaimedTask.isRead()).isTrue();
assertThat(unclaimedTask.getOwner()).isNull();
}
@WithAccessId(
@ -165,14 +176,14 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.completeTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000032");
assertNotNull(completedTask);
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted());
assertEquals(completedTask.getCompleted(), completedTask.getModified());
assertTrue(completedTask.getCompleted().isAfter(before));
assertTrue(completedTask.getModified().isAfter(before));
assertTrue(completedTask.isRead());
assertEquals("user_1_2", completedTask.getOwner());
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.getCompleted().isAfter(before)).isTrue();
assertThat(completedTask.getModified().isAfter(before)).isTrue();
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user_1_2");
}
@WithAccessId(
@ -188,12 +199,12 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000033");
assertNotNull(completedTask);
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted());
assertEquals(completedTask.getCompleted(), completedTask.getModified());
assertTrue(completedTask.isRead());
assertEquals("user_1_2", completedTask.getOwner());
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user_1_2");
}
@WithAccessId(
@ -205,8 +216,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000034");
Assertions.assertThrows(
InvalidOwnerException.class, () -> taskService.completeTask(claimedTask.getId()));
// Assertions.assertThrows(
// InvalidOwnerException.class, () -> taskService.completeTask(claimedTask.getId()));
ThrowingCallable call =
() -> {
taskService.completeTask(claimedTask.getId());
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(
@ -222,12 +238,12 @@ class WorkOnTaskAccTest extends AbstractAccTest {
taskService.forceCompleteTask(claimedTask.getId());
Task completedTask = taskService.getTask("TKI:000000000000000000000000000000000035");
assertNotNull(completedTask);
assertEquals(TaskState.COMPLETED, completedTask.getState());
assertNotNull(completedTask.getCompleted());
assertEquals(completedTask.getCompleted(), completedTask.getModified());
assertTrue(completedTask.isRead());
assertEquals("user_1_2", completedTask.getOwner());
assertThat(completedTask).isNotNull();
assertThat(completedTask.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask.getCompleted()).isNotNull();
assertThat(completedTask.getModified()).isEqualTo(completedTask.getCompleted());
assertThat(completedTask.isRead()).isTrue();
assertThat(completedTask.getOwner()).isEqualTo("user_1_2");
}
@WithAccessId(
@ -244,13 +260,13 @@ class WorkOnTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results = taskService.completeTasks(taskIdList);
assertFalse(results.containsErrors());
assertThat(results.containsErrors()).isFalse();
Task completedTask1 = taskService.getTask("TKI:000000000000000000000000000000000100");
assertEquals(TaskState.COMPLETED, completedTask1.getState());
assertNotNull(completedTask1.getCompleted());
assertThat(completedTask1.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask1.getCompleted()).isNotNull();
Task completedTask2 = taskService.getTask("TKI:000000000000000000000000000000000101");
assertEquals(TaskState.COMPLETED, completedTask2.getState());
assertNotNull(completedTask2.getCompleted());
assertThat(completedTask2.getState()).isEqualTo(TaskState.COMPLETED);
assertThat(completedTask2.getCompleted()).isNotNull();
}
@WithAccessId(
@ -266,13 +282,15 @@ class WorkOnTaskAccTest extends AbstractAccTest {
BulkOperationResults<String, TaskanaException> results = taskService.deleteTasks(taskIdList);
assertTrue(results.containsErrors());
assertThat(results.getErrorMap().size(), equalTo(2));
assertTrue(
results.getErrorForId("TKI:000000000000000000000000000000003333")
instanceof TaskNotFoundException);
assertTrue(
results.getErrorForId("TKI:000000000000000000000000000000000102")
instanceof InvalidStateException);
assertThat(results.containsErrors()).isTrue();
assertThat(results.getErrorMap()).hasSize(2);
assertThat(
results.getErrorForId("TKI:000000000000000000000000000000003333")
instanceof TaskNotFoundException)
.isTrue();
assertThat(
results.getErrorForId("TKI:000000000000000000000000000000000102")
instanceof InvalidStateException)
.isTrue();
}
}

109
lib/taskana-core/src/test/java/acceptance/workbasket/CreateWorkbasketAccTest.java
View File

@ -1,13 +1,11 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -24,7 +22,6 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
import pro.taskana.workbasket.internal.models.WorkbasketImpl;
/** Acceptance test for all "create workbasket" scenarios. */
@ExtendWith(JaasExtension.class)
@ -56,15 +53,15 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
workbasketService.createWorkbasketAccessItem(wbai);
int after = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();
assertEquals(before + 1, after);
assertThat(after).isEqualTo(before + 1);
Workbasket createdWorkbasket = workbasketService.getWorkbasket("NT1234", "DOMAIN_A");
assertNotNull(createdWorkbasket);
assertNotNull(createdWorkbasket.getId());
assertTrue(createdWorkbasket.getId().startsWith("WBI"));
assertEquals(workbasket, createdWorkbasket);
assertThat(createdWorkbasket).isNotNull();
assertThat(createdWorkbasket.getId()).isNotNull();
assertThat(createdWorkbasket.getId().startsWith("WBI")).isTrue();
assertThat(createdWorkbasket).isEqualTo(workbasket);
Workbasket createdWorkbasket2 = workbasketService.getWorkbasket(createdWorkbasket.getId());
assertNotNull(createdWorkbasket);
assertEquals(createdWorkbasket, createdWorkbasket2);
assertThat(createdWorkbasket).isNotNull();
assertThat(createdWorkbasket2).isEqualTo(createdWorkbasket);
}
@WithAccessId(userName = "dummy")
@ -77,8 +74,8 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
Assertions.assertThrows(
NotAuthorizedException.class, () -> workbasketService.createWorkbasket(workbasket));
ThrowingCallable call = () -> workbasketService.createWorkbasket(workbasket);
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -87,14 +84,13 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@Test
void should_beAbleToCreateNewWorkbasket_When_WorkbasketCopy() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketImpl oldWorkbasket =
(WorkbasketImpl) workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
Workbasket oldWorkbasket = workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
WorkbasketImpl newWorkbasket = oldWorkbasket.copy("keyname");
newWorkbasket = (WorkbasketImpl) workbasketService.createWorkbasket(newWorkbasket);
Workbasket newWorkbasket = oldWorkbasket.copy("keyname");
newWorkbasket = workbasketService.createWorkbasket(newWorkbasket);
assertNotNull(newWorkbasket.getId());
assertNotEquals(newWorkbasket.getId(), oldWorkbasket.getId());
assertThat(newWorkbasket.getId()).isNotNull();
assertThat(newWorkbasket.getId()).isNotEqualTo(oldWorkbasket.getId());
}
@WithAccessId(
@ -108,8 +104,8 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
workbasket.setName("Megabasket");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
Assertions.assertThrows(
DomainNotFoundException.class, () -> workbasketService.createWorkbasket(workbasket));
ThrowingCallable call = () -> workbasketService.createWorkbasket(workbasket);
assertThatThrownBy(call).isInstanceOf(DomainNotFoundException.class);
}
@WithAccessId(
@ -125,46 +121,58 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
// missing key
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket));
ThrowingCallable call = () -> workbasketService.createWorkbasket(workbasket);
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
Workbasket workbasket2 = workbasketService.newWorkbasket("key", "novatec");
workbasket2.setType(WorkbasketType.GROUP);
workbasket2.setOrgLevel1("company");
// missing name
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket2));
call =
() -> {
workbasketService.createWorkbasket(workbasket2);
};
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
Workbasket workbasket3 = workbasketService.newWorkbasket("key", "novatec");
workbasket3.setName("Megabasket");
workbasket3.setOrgLevel1("company");
// missing type
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket3));
call = () -> workbasketService.createWorkbasket(workbasket3);
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
Workbasket workbasket4 = workbasketService.newWorkbasket("key", null);
workbasket4.setName("Megabasket");
workbasket4.setType(WorkbasketType.GROUP);
workbasket4.setOrgLevel1("company");
// missing domain
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket4));
call =
() -> {
workbasketService.createWorkbasket(workbasket4);
};
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
Workbasket workbasket5 = workbasketService.newWorkbasket("", "novatec");
workbasket5.setName("Megabasket");
workbasket5.setType(WorkbasketType.GROUP);
workbasket5.setOrgLevel1("company");
// empty key
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket5));
call =
() -> {
workbasketService.createWorkbasket(workbasket5);
};
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
Workbasket workbasket6 = workbasketService.newWorkbasket("key", "novatec");
workbasket6.setName("");
workbasket6.setType(WorkbasketType.GROUP);
workbasket6.setOrgLevel1("company");
// empty name
Assertions.assertThrows(
InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket));
call =
() -> {
workbasketService.createWorkbasket(workbasket);
};
assertThatThrownBy(call).isInstanceOf(InvalidWorkbasketException.class);
}
@WithAccessId(
@ -186,9 +194,11 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
duplicateWorkbasketWithSmallX.setName("Personal Workbasket for UID X123456");
duplicateWorkbasketWithSmallX.setType(WorkbasketType.PERSONAL);
Assertions.assertThrows(
WorkbasketAlreadyExistException.class,
() -> workbasketService.createWorkbasket(duplicateWorkbasketWithSmallX));
ThrowingCallable call =
() -> {
workbasketService.createWorkbasket(duplicateWorkbasketWithSmallX);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketAlreadyExistException.class);
}
@WithAccessId(
@ -210,9 +220,11 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
sameKeyAndDomain.setType(WorkbasketType.TOPIC);
sameKeyAndDomain.setName("new name");
Assertions.assertThrows(
WorkbasketAlreadyExistException.class,
() -> workbasketService.createWorkbasket(sameKeyAndDomain));
ThrowingCallable call =
() -> {
workbasketService.createWorkbasket(sameKeyAndDomain);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketAlreadyExistException.class);
}
@WithAccessId(
@ -238,14 +250,14 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
workbasketService.createWorkbasketAccessItem(wbai);
Workbasket createdWorkbasket = workbasketService.getWorkbasket("WBAIT1234", "DOMAIN_A");
assertNotNull(createdWorkbasket);
assertNotNull(createdWorkbasket.getId());
assertThat(createdWorkbasket).isNotNull();
assertThat(createdWorkbasket.getId()).isNotNull();
List<WorkbasketAccessItem> accessItems =
workbasketService.getWorkbasketAccessItems(createdWorkbasket.getId());
WorkbasketAccessItem item =
accessItems.stream().filter(t -> wbai.getId().equals(t.getId())).findFirst().orElse(null);
assertEquals("Karl Napf", item.getAccessName());
assertThat(item.getAccessName()).isEqualTo("Karl Napf");
}
@WithAccessId(
@ -254,7 +266,6 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@Test
void testCreateDuplicateWorkbasketAccessListFails() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
final int before = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();
Workbasket workbasket = workbasketService.newWorkbasket("NT4321", "DOMAIN_A");
workbasket.setName("Terabasket");
@ -266,8 +277,10 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
wbai.setPermRead(true);
workbasketService.createWorkbasketAccessItem(wbai);
Assertions.assertThrows(
WorkbasketAccessItemAlreadyExistException.class,
() -> workbasketService.createWorkbasketAccessItem(wbai));
ThrowingCallable call =
() -> {
workbasketService.createWorkbasketAccessItem(wbai);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketAccessItemAlreadyExistException.class);
}
}

104
lib/taskana-core/src/test/java/acceptance/workbasket/DeleteWorkbasketAccTest.java
View File

@ -1,14 +1,11 @@
package acceptance.workbasket;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -50,34 +47,37 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
void testDeleteWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException {
Workbasket wb = workbasketService.getWorkbasket("USER_2_2", "DOMAIN_A");
Assertions.assertThrows(
WorkbasketNotFoundException.class,
ThrowingCallable call =
() -> {
workbasketService.deleteWorkbasket(wb.getId());
workbasketService.getWorkbasket("USER_2_2", "DOMAIN_A");
},
"There should be no result for a deleted Workbasket.");
};
assertThatThrownBy(call)
.describedAs("There should be no result for a deleted Workbasket.")
.isInstanceOf(WorkbasketNotFoundException.class);
}
@WithAccessId(userName = "elena")
@Test
void testDeleteWorkbasketNotAuthorized() {
Assertions.assertThrows(
NotAuthorizedException.class,
ThrowingCallable call =
() -> {
Workbasket wb = workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A");
workbasketService.deleteWorkbasket(wb.getId());
});
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(userName = "elena")
@Test
void testGetWorkbasketNotAuthorized() {
Assertions.assertThrows(
NotAuthorizedException.class,
() -> workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -90,19 +90,19 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
int distTargets =
workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000001").size();
Assertions.assertThrows(
WorkbasketNotFoundException.class,
ThrowingCallable call =
() -> {
// WB deleted
workbasketService.deleteWorkbasket(wb.getId());
workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
},
"There should be no result for a deleted Workbasket.");
};
assertThatThrownBy(call)
.describedAs("There should be no result for a deleted Workbasket.")
.isInstanceOf(WorkbasketNotFoundException.class);
int newDistTargets =
workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000001").size();
assertThat(newDistTargets, equalTo(3));
assertTrue(newDistTargets < distTargets);
assertThat(newDistTargets).isEqualTo(3).isLessThan(distTargets);
}
@WithAccessId(
@ -111,18 +111,26 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@Test
void testDeleteWorkbasketWithNullOrEmptyParam() {
// Test Null-Value
Assertions.assertThrows(
InvalidArgumentException.class,
() -> workbasketService.deleteWorkbasket(null),
"delete() should have thrown an InvalidArgumentException, " + "when the param ID is null.");
ThrowingCallable call =
() -> {
workbasketService.deleteWorkbasket(null);
};
assertThatThrownBy(call)
.describedAs(
"delete() should have thrown an InvalidArgumentException, "
+ "when the param ID is null.")
.isInstanceOf(InvalidArgumentException.class);
// Test EMPTY-Value
Assertions.assertThrows(
InvalidArgumentException.class,
() -> workbasketService.deleteWorkbasket(""),
"delete() should have thrown an InvalidArgumentException, "
+ "when the param ID is EMPTY-String.");
call =
() -> {
workbasketService.deleteWorkbasket("");
};
assertThatThrownBy(call)
.describedAs(
"delete() should have thrown an InvalidArgumentException, \"\n"
+ " + \"when the param ID is EMPTY-String.")
.isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(
@ -130,9 +138,11 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testDeleteWorkbasketButNotExisting() {
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.deleteWorkbasket("SOME NOT EXISTING ID"));
ThrowingCallable call =
() -> {
workbasketService.deleteWorkbasket("SOME NOT EXISTING ID");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@WithAccessId(
@ -143,8 +153,11 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
throws WorkbasketNotFoundException, NotAuthorizedException {
Workbasket wb =
workbasketService.getWorkbasket("USER_1_2", "DOMAIN_A"); // all rights, DOMAIN_A with Tasks
Assertions.assertThrows(
WorkbasketInUseException.class, () -> workbasketService.deleteWorkbasket(wb.getId()));
ThrowingCallable call =
() -> {
workbasketService.deleteWorkbasket(wb.getId());
};
assertThatThrownBy(call).isInstanceOf(WorkbasketInUseException.class);
}
@WithAccessId(
@ -168,18 +181,19 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
accessItem.setPermOpen(true);
workbasketService.createWorkbasketAccessItem(accessItem);
List<WorkbasketAccessItem> accessItemsBefore = workbasketService.getWorkbasketAccessItems(wbId);
assertEquals(5, accessItemsBefore.size());
assertThat(accessItemsBefore).hasSize(5);
Assertions.assertThrows(
WorkbasketNotFoundException.class,
ThrowingCallable call =
() -> {
workbasketService.deleteWorkbasket(wbId);
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000008");
},
"There should be no result for a deleted Workbasket.");
};
assertThatThrownBy(call)
.describedAs("There should be no result for a deleted Workbasket.")
.isInstanceOf(WorkbasketNotFoundException.class);
List<WorkbasketAccessItem> accessItemsAfter = workbasketService.getWorkbasketAccessItems(wbId);
assertEquals(0, accessItemsAfter.size());
assertThat(accessItemsAfter).isEmpty();
}
@WithAccessId(
@ -201,9 +215,9 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
taskService.forceCompleteTask(task.getId());
boolean markedForDeletion = workbasketService.deleteWorkbasket(wb.getId());
assertFalse(markedForDeletion);
assertThat(markedForDeletion).isFalse();
Workbasket wb2 = workbasketService.getWorkbasket(wb.getId());
assertTrue(wb2.isMarkedForDeletion());
assertThat(wb2.isMarkedForDeletion()).isTrue();
}
}

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

@ -1,7 +1,7 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.io.IOException;
@ -10,7 +10,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -43,7 +43,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> retrievedDistributionTargets =
workbasketService.getDistributionTargets(workbasketSummary.getId());
assertEquals(4, retrievedDistributionTargets.size());
assertThat(retrievedDistributionTargets).hasSize(4);
List<String> expectedTargetIds =
new ArrayList<>(
Arrays.asList(
@ -53,7 +53,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000005"));
for (WorkbasketSummary wbSummary : retrievedDistributionTargets) {
assertTrue(expectedTargetIds.contains(wbSummary.getId()));
assertThat(expectedTargetIds.contains(wbSummary.getId())).isTrue();
}
}
@ -71,7 +71,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
workbasketService.getDistributionTargets(
workbasketSummary.getKey(), workbasketSummary.getDomain());
assertEquals(4, retrievedDistributionTargets.size());
assertThat(retrievedDistributionTargets).hasSize(4);
List<String> expectedTargetIds =
new ArrayList<>(
Arrays.asList(
@ -81,7 +81,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000005"));
for (WorkbasketSummary wbSummary : retrievedDistributionTargets) {
assertTrue(expectedTargetIds.contains(wbSummary.getId()));
assertThat(expectedTargetIds.contains(wbSummary.getId())).isTrue();
}
}
@ -95,25 +95,30 @@ class DistributionTargetsAccTest extends AbstractAccTest {
String existingWb = "WBI:100000000000000000000000000000000001";
String nonExistingWb = "WBI:100000000000000000000000000000000xx1";
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000xx1"));
ThrowingCallable call =
() -> {
workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000xx1");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() ->
workbasketService.setDistributionTargets(
existingWb, new ArrayList<>(Arrays.asList(nonExistingWb))));
call =
() -> {
workbasketService.setDistributionTargets(
existingWb, new ArrayList<>(Arrays.asList(nonExistingWb)));
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.addDistributionTarget(existingWb, nonExistingWb));
call =
() -> {
workbasketService.addDistributionTarget(existingWb, nonExistingWb);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
int beforeCount = workbasketService.getDistributionTargets(existingWb).size();
workbasketService.removeDistributionTarget(existingWb, nonExistingWb);
int afterCount = workbasketService.getDistributionTargets(existingWb).size();
assertEquals(afterCount, beforeCount);
assertThat(beforeCount).isEqualTo(afterCount);
}
@WithAccessId(
@ -124,26 +129,32 @@ class DistributionTargetsAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
String existingWb = "WBI:100000000000000000000000000000000001";
Assertions.assertThrows(
NotAuthorizedException.class, () -> workbasketService.getDistributionTargets(existingWb));
ThrowingCallable call =
() -> {
workbasketService.getDistributionTargets(existingWb);
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService.setDistributionTargets(
existingWb, Arrays.asList("WBI:100000000000000000000000000000000002")));
call =
() -> {
workbasketService.setDistributionTargets(
existingWb, Arrays.asList("WBI:100000000000000000000000000000000002"));
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService.addDistributionTarget(
existingWb, "WBI:100000000000000000000000000000000002"));
call =
() -> {
workbasketService.addDistributionTarget(
existingWb, "WBI:100000000000000000000000000000000002");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService.removeDistributionTarget(
existingWb, "WBI:100000000000000000000000000000000002"));
call =
() -> {
workbasketService.removeDistributionTarget(
existingWb, "WBI:100000000000000000000000000000000002");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -157,24 +168,24 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionTargets =
workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(4, distributionTargets.size());
assertThat(distributionTargets).hasSize(4);
// add a new distribution target
Workbasket newTarget = workbasketService.getWorkbasket("GPK_B_KSC_2", "DOMAIN_B");
workbasketService.addDistributionTarget(workbasket.getId(), newTarget.getId());
distributionTargets = workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(5, distributionTargets.size());
assertThat(distributionTargets).hasSize(5);
// remove the new target
workbasketService.removeDistributionTarget(workbasket.getId(), newTarget.getId());
distributionTargets = workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(4, distributionTargets.size());
assertThat(distributionTargets).hasSize(4);
// remove the new target again Question: should this throw an exception?
workbasketService.removeDistributionTarget(workbasket.getId(), newTarget.getId());
distributionTargets = workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(4, distributionTargets.size());
assertThat(distributionTargets).hasSize(4);
}
@WithAccessId(
@ -188,19 +199,19 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionTargets =
workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(0, distributionTargets.size());
assertThat(distributionTargets).isEmpty();
// add a new distribution target
Workbasket newTarget = workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
workbasketService.addDistributionTarget(workbasket.getId(), newTarget.getId());
distributionTargets = workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(1, distributionTargets.size());
assertThat(distributionTargets).hasSize(1);
// remove the new target
workbasketService.removeDistributionTarget(workbasket.getId(), newTarget.getId());
distributionTargets = workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(0, distributionTargets.size());
assertThat(distributionTargets).isEmpty();
}
@WithAccessId(
@ -214,14 +225,16 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionTargets =
workbasketService.getDistributionTargets(workbasket.getId());
assertEquals(4, distributionTargets.size());
assertThat(distributionTargets).hasSize(4);
// add a new distribution target
Workbasket newTarget = workbasketService.getWorkbasket("GPK_B_KSC_2", "DOMAIN_B");
Assertions.assertThrows(
NotAuthorizedException.class,
() -> workbasketService.addDistributionTarget(workbasket.getId(), newTarget.getId()));
ThrowingCallable call =
() -> {
workbasketService.addDistributionTarget(workbasket.getId(), newTarget.getId());
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -236,11 +249,11 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> initialDistributionTargets =
workbasketService.getDistributionTargets(sourceWorkbasket.getId());
assertEquals(4, initialDistributionTargets.size());
assertThat(initialDistributionTargets).hasSize(4);
List<WorkbasketSummary> newDistributionTargets =
workbasketService.createWorkbasketQuery().keyIn("USER_1_1", "GPK_B_KSC_1").list();
assertEquals(2, newDistributionTargets.size());
assertThat(newDistributionTargets).hasSize(2);
List<String> newDistributionTargetIds =
newDistributionTargets.stream().map(WorkbasketSummary::getId).collect(Collectors.toList());
@ -248,7 +261,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
workbasketService.setDistributionTargets(sourceWorkbasket.getId(), newDistributionTargetIds);
List<WorkbasketSummary> changedTargets =
workbasketService.getDistributionTargets(sourceWorkbasket.getId());
assertEquals(2, changedTargets.size());
assertThat(changedTargets).hasSize(2);
// reset DB to original state
resetDb(false);
@ -264,7 +277,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionSources =
workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
assertEquals(2, distributionSources.size());
assertThat(distributionSources).hasSize(2);
List<String> expectedIds =
new ArrayList<>(
Arrays.asList(
@ -272,7 +285,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000002"));
for (WorkbasketSummary foundSummary : distributionSources) {
assertTrue(expectedIds.contains(foundSummary.getId()));
assertThat(expectedIds.contains(foundSummary.getId())).isTrue();
}
}
@ -287,7 +300,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
List<WorkbasketSummary> distributionSources =
workbasketService.getDistributionSources("TEAMLEAD_1", "DOMAIN_A");
assertEquals(2, distributionSources.size());
assertThat(distributionSources).hasSize(2);
List<String> expectedIds =
new ArrayList<>(
Arrays.asList(
@ -295,7 +308,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000002"));
for (WorkbasketSummary foundSummary : distributionSources) {
assertTrue(expectedIds.contains(foundSummary.getId()));
assertThat(expectedIds.contains(foundSummary.getId())).isTrue();
}
}
@ -306,9 +319,11 @@ class DistributionTargetsAccTest extends AbstractAccTest {
void testQueryDistributionSourcesThrowsNotAuthorized() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004"));
ThrowingCallable call =
() -> {
workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -318,8 +333,10 @@ class DistributionTargetsAccTest extends AbstractAccTest {
void testQueryDistributionSourcesThrowsWorkbasketNotFound() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004"));
ThrowingCallable call =
() -> {
workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
}

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

@ -1,11 +1,11 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -37,20 +37,20 @@ class GetWorkbasketAccTest extends AbstractAccTest {
Workbasket workbasket =
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000007");
assertEquals("DOMAIN_A", workbasket.getDomain());
assertEquals("PPK User 2 KSC 1", workbasket.getDescription());
assertEquals("PPK User 2 KSC 1", workbasket.getName());
assertEquals("USER_1_2", workbasket.getKey());
assertEquals(WorkbasketType.PERSONAL, workbasket.getType());
assertEquals("Peter Maier", workbasket.getOwner());
assertEquals("versicherung", workbasket.getOrgLevel1());
assertEquals("abteilung", workbasket.getOrgLevel2());
assertEquals("projekt", workbasket.getOrgLevel3());
assertEquals("team", workbasket.getOrgLevel4());
assertEquals("custom1", workbasket.getCustom1());
assertEquals("custom2", workbasket.getCustom2());
assertEquals("custom3", workbasket.getCustom3());
assertEquals("custom4", workbasket.getCustom4());
assertThat(workbasket.getDomain()).isEqualTo("DOMAIN_A");
assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getName()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getKey()).isEqualTo("USER_1_2");
assertThat(workbasket.getType()).isEqualTo(WorkbasketType.PERSONAL);
assertThat(workbasket.getOwner()).isEqualTo("Peter Maier");
assertThat(workbasket.getOrgLevel1()).isEqualTo("versicherung");
assertThat(workbasket.getOrgLevel2()).isEqualTo("abteilung");
assertThat(workbasket.getOrgLevel3()).isEqualTo("projekt");
assertThat(workbasket.getOrgLevel4()).isEqualTo("team");
assertThat(workbasket.getCustom1()).isEqualTo("custom1");
assertThat(workbasket.getCustom2()).isEqualTo("custom2");
assertThat(workbasket.getCustom3()).isEqualTo("custom3");
assertThat(workbasket.getCustom4()).isEqualTo("custom4");
}
@WithAccessId(
@ -63,19 +63,19 @@ class GetWorkbasketAccTest extends AbstractAccTest {
Workbasket workbasket = workbasketService.getWorkbasket("USER_1_2", "DOMAIN_A");
assertEquals("WBI:100000000000000000000000000000000007", workbasket.getId());
assertEquals("PPK User 2 KSC 1", workbasket.getDescription());
assertEquals("PPK User 2 KSC 1", workbasket.getName());
assertEquals(WorkbasketType.PERSONAL, workbasket.getType());
assertEquals("Peter Maier", workbasket.getOwner());
assertEquals("versicherung", workbasket.getOrgLevel1());
assertEquals("abteilung", workbasket.getOrgLevel2());
assertEquals("projekt", workbasket.getOrgLevel3());
assertEquals("team", workbasket.getOrgLevel4());
assertEquals("custom1", workbasket.getCustom1());
assertEquals("custom2", workbasket.getCustom2());
assertEquals("custom3", workbasket.getCustom3());
assertEquals("custom4", workbasket.getCustom4());
assertThat(workbasket.getId()).isEqualTo("WBI:100000000000000000000000000000000007");
assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getName()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getType()).isEqualTo(WorkbasketType.PERSONAL);
assertThat(workbasket.getOwner()).isEqualTo("Peter Maier");
assertThat(workbasket.getOrgLevel1()).isEqualTo("versicherung");
assertThat(workbasket.getOrgLevel2()).isEqualTo("abteilung");
assertThat(workbasket.getOrgLevel3()).isEqualTo("projekt");
assertThat(workbasket.getOrgLevel4()).isEqualTo("team");
assertThat(workbasket.getCustom1()).isEqualTo("custom1");
assertThat(workbasket.getCustom2()).isEqualTo("custom2");
assertThat(workbasket.getCustom3()).isEqualTo("custom3");
assertThat(workbasket.getCustom4()).isEqualTo("custom4");
}
@WithAccessId(
@ -87,11 +87,11 @@ class GetWorkbasketAccTest extends AbstractAccTest {
List<WorkbasketPermission> permissions =
workbasketService.getPermissionsForWorkbasket("WBI:100000000000000000000000000000000007");
assertEquals(4, permissions.size());
assertTrue(permissions.contains(WorkbasketPermission.READ));
assertTrue(permissions.contains(WorkbasketPermission.OPEN));
assertTrue(permissions.contains(WorkbasketPermission.TRANSFER));
assertTrue(permissions.contains(WorkbasketPermission.APPEND));
assertThat(permissions).hasSize(4);
assertThat(permissions.contains(WorkbasketPermission.READ)).isTrue();
assertThat(permissions.contains(WorkbasketPermission.OPEN)).isTrue();
assertThat(permissions.contains(WorkbasketPermission.TRANSFER)).isTrue();
assertThat(permissions.contains(WorkbasketPermission.APPEND)).isTrue();
}
@WithAccessId(
@ -103,7 +103,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
List<WorkbasketPermission> permissions =
workbasketService.getPermissionsForWorkbasket("WBI:invalid");
assertEquals(0, permissions.size());
assertThat(permissions).isEmpty();
}
@WithAccessId(
@ -116,52 +116,62 @@ class GetWorkbasketAccTest extends AbstractAccTest {
WorkbasketSummary workbasketSummary =
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000007").asSummary();
assertEquals("DOMAIN_A", workbasketSummary.getDomain());
assertEquals("PPK User 2 KSC 1", workbasketSummary.getDescription());
assertEquals("PPK User 2 KSC 1", workbasketSummary.getName());
assertEquals("USER_1_2", workbasketSummary.getKey());
assertEquals(WorkbasketType.PERSONAL, workbasketSummary.getType());
assertEquals("Peter Maier", workbasketSummary.getOwner());
assertEquals("versicherung", workbasketSummary.getOrgLevel1());
assertEquals("abteilung", workbasketSummary.getOrgLevel2());
assertEquals("projekt", workbasketSummary.getOrgLevel3());
assertEquals("team", workbasketSummary.getOrgLevel4());
assertEquals("custom1", workbasketSummary.getCustom1());
assertEquals("custom2", workbasketSummary.getCustom2());
assertEquals("custom3", workbasketSummary.getCustom3());
assertEquals("custom4", workbasketSummary.getCustom4());
assertEquals(false, workbasketSummary.isMarkedForDeletion());
assertThat(workbasketSummary.getDomain()).isEqualTo("DOMAIN_A");
assertThat(workbasketSummary.getDescription()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasketSummary.getName()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasketSummary.getKey()).isEqualTo("USER_1_2");
assertThat(workbasketSummary.getType()).isEqualTo(WorkbasketType.PERSONAL);
assertThat(workbasketSummary.getOwner()).isEqualTo("Peter Maier");
assertThat(workbasketSummary.getOrgLevel1()).isEqualTo("versicherung");
assertThat(workbasketSummary.getOrgLevel2()).isEqualTo("abteilung");
assertThat(workbasketSummary.getOrgLevel3()).isEqualTo("projekt");
assertThat(workbasketSummary.getOrgLevel4()).isEqualTo("team");
assertThat(workbasketSummary.getCustom1()).isEqualTo("custom1");
assertThat(workbasketSummary.getCustom2()).isEqualTo("custom2");
assertThat(workbasketSummary.getCustom3()).isEqualTo("custom3");
assertThat(workbasketSummary.getCustom4()).isEqualTo("custom4");
assertThat(workbasketSummary.isMarkedForDeletion()).isEqualTo(false);
}
@Test
void testThrowsExceptionIfIdIsInvalid() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> workbasketService.getWorkbasket("INVALID_ID"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("INVALID_ID");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@Test
void testThrowsExceptionIfKeyOrDomainIsInvalid() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.getWorkbasket("INVALID_KEY", "INVALID_DOMAIN"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("INVALID_KEY", "INVALID_DOMAIN");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@Test
void testGetByIdNotAuthorized() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
NotAuthorizedException.class,
() -> workbasketService.getWorkbasket("WBI:100000000000000000000000000000000001"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000001");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@Test
void testGetByKeyDomainNotAuthorized() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
NotAuthorizedException.class, () -> workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -170,8 +180,10 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@Test
void testGetWorkbasketByIdNotExisting() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketService.getWorkbasket("NOT EXISTING ID"));
ThrowingCallable call =
() -> {
workbasketService.getWorkbasket("NOT EXISTING ID");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
}

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

@ -1,18 +1,20 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static java.lang.String.CASE_INSENSITIVE_ORDER;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.util.IterableUtil.toArray;
import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
import static pro.taskana.workbasket.api.WorkbasketQueryColumnName.NAME;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.security.JaasExtension;
@ -27,11 +29,11 @@ import pro.taskana.workbasket.api.models.WorkbasketSummary;
@ExtendWith(JaasExtension.class)
class QueryWorkbasketAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
private static WorkbasketService workbasketService;
QueryWorkbasketAccTest() {
super();
@BeforeAll
static void setup() {
workbasketService = taskanaEngine.getWorkbasketService();
}
@WithAccessId(
@ -39,16 +41,15 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1_1"})
@Test
void testQueryAllForUserMultipleTimes() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
long count = query.count();
assertEquals(4, count);
int count = (int) query.count();
assertThat(count).isEqualTo(4);
List<WorkbasketSummary> workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(
@ -56,16 +57,15 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
void testQueryAllForBusinessAdminMultipleTimes() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
long count = query.count();
assertEquals(25, count);
int count = (int) query.count();
assertThat(count).isEqualTo(25);
List<WorkbasketSummary> workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(
@ -73,16 +73,15 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"admin"})
@Test
void testQueryAllForAdminMultipleTimes() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketQuery query = workbasketService.createWorkbasketQuery();
long count = query.count();
assertEquals(25, count);
int count = (int) query.count();
assertThat(count).isEqualTo(25);
List<WorkbasketSummary> workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
workbaskets = query.list();
assertNotNull(workbaskets);
assertEquals(count, workbaskets.size());
assertThat(workbaskets).isNotNull();
assertThat(workbaskets).hasSize(count);
}
@WithAccessId(
@ -90,19 +89,18 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketValuesForColumnName() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<String> columnValueList = workbasketService.createWorkbasketQuery().listValues(NAME, null);
assertNotNull(columnValueList);
assertEquals(10, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(10);
columnValueList =
workbasketService
.createWorkbasketQuery()
.nameLike("%korb%")
.orderByName(asc)
.listValues(NAME, SortDirection.DESCENDING); // will override
assertNotNull(columnValueList);
assertEquals(4, columnValueList.size());
.orderByName(ASCENDING)
.listValues(NAME, DESCENDING); // will override
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(4);
}
@WithAccessId(
@ -110,10 +108,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByDomain() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_B").list();
assertEquals(1L, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(
@ -121,14 +118,13 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByDomainAndType() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.typeIn(WorkbasketType.PERSONAL)
.list();
assertEquals(6L, results.size());
assertThat(results).hasSize(6);
}
@WithAccessId(
@ -136,11 +132,13 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByName() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameIn("Gruppenpostkorb KSC").list();
assertEquals(1L, results.size());
assertEquals("GPK_KSC", results.get(0).getKey());
assertThat(results)
.hasSize(1)
.first()
.extracting(WorkbasketSummary::getKey)
.isEqualTo("GPK_KSC");
}
@WithAccessId(
@ -148,10 +146,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByNameStartsWith() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%Gruppenpostkorb KSC%").list();
assertEquals(3L, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -159,13 +156,12 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByNameContains() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.nameLike("%Teamlead%", "%Gruppenpostkorb KSC%")
.list();
assertEquals(5L, results.size());
assertThat(results).hasSize(5);
}
@WithAccessId(
@ -173,10 +169,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByNameContainsCaseInsensitive() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%TEAMLEAD%").list();
assertEquals(2L, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(
@ -184,15 +179,14 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByDescription() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.descriptionLike("%ppk%", "%gruppen%")
.orderByType(desc)
.orderByDescription(asc)
.orderByType(DESCENDING)
.orderByDescription(ASCENDING)
.list();
assertEquals(9L, results.size());
assertThat(results).hasSize(9);
}
@WithAccessId(
@ -200,14 +194,13 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByOwnerLike() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.ownerLike("%an%", "%te%")
.orderByOwner(asc)
.orderByOwner(ASCENDING)
.list();
assertEquals(1L, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(
@ -215,10 +208,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByKey() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").list();
assertEquals(1L, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(
@ -226,10 +218,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByMultipleKeys() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC_1", "GPK_KSC").list();
assertEquals(2L, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(
@ -237,10 +228,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByMultipleKeysWithUnknownKey() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC_1", "GPK_Ksc", "GPK_KSC_3").list();
assertEquals(2L, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(
@ -248,10 +238,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByKeyContains() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyLike("%KSC%").list();
assertEquals(3L, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -259,10 +248,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByKeyContainsIgnoreCase() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyLike("%kSc%").list();
assertEquals(3L, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -270,10 +258,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByKeyOrNameContainsIgnoreCase() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().keyOrNameLike("%kSc%").list();
assertEquals(9L, results.size());
assertThat(results).hasSize(9);
}
@WithAccessId(
@ -281,75 +268,53 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByNameStartsWithSortedByNameAscending() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
.createWorkbasketQuery()
.nameLike("%Gruppenpostkorb KSC%")
.orderByName(asc)
.orderByName(ASCENDING)
.list();
assertEquals(3L, results.size());
assertEquals("GPK_KSC", results.get(0).getKey());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
assertTrue(wbSummary.getName().compareToIgnoreCase(previousSummary.getName()) >= 0);
}
previousSummary = wbSummary;
}
assertThat(results)
.hasSize(3)
.extracting(WorkbasketSummary::getName)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "max")
@Test
void testQueryWorkbasketByNameStartsWithSortedByNameDescending() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByName(desc).list();
assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
assertTrue(wbSummary.getName().compareToIgnoreCase(previousSummary.getName()) <= 0);
}
previousSummary = wbSummary;
}
workbasketService
.createWorkbasketQuery()
.nameLike("basxet%")
.orderByName(DESCENDING)
.list();
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getName)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@WithAccessId(userName = "max")
@Test
void testQueryWorkbasketByNameStartsWithSortedByKeyAscending() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(asc).list();
assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
assertTrue(wbSummary.getKey().compareToIgnoreCase(previousSummary.getKey()) >= 0);
}
previousSummary = wbSummary;
}
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(ASCENDING).list();
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getKey)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "max")
@Test
void testQueryWorkbasketByNameStartsWithSortedByKeyDescending() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(desc).list();
assertEquals(10L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
assertTrue(wbSummary.getKey().compareToIgnoreCase(previousSummary.getKey()) <= 0);
}
previousSummary = wbSummary;
}
workbasketService.createWorkbasketQuery().nameLike("basxet%").orderByKey(DESCENDING).list();
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getKey)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@WithAccessId(
@ -357,10 +322,9 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByCreated() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().createdWithin(todaysInterval()).list();
assertEquals(9L, results.size());
assertThat(results).hasSize(9);
}
@WithAccessId(
@ -368,27 +332,20 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryWorkbasketByModified() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().modifiedWithin(todaysInterval()).list();
assertEquals(9L, results.size());
assertThat(results).hasSize(9);
}
@WithAccessId(userName = "unknown", groupNames = "admin")
@Test
void testQueryWorkbasketByAdmin() throws NotAuthorizedException, InvalidArgumentException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").orderByName(desc).list();
assertEquals(25L, results.size());
// check sort order is correct
WorkbasketSummary previousSummary = null;
for (WorkbasketSummary wbSummary : results) {
if (previousSummary != null) {
assertTrue(wbSummary.getName().compareToIgnoreCase(previousSummary.getName()) <= 0);
}
previousSummary = wbSummary;
}
workbasketService.createWorkbasketQuery().nameLike("%").orderByName(DESCENDING).list();
assertThat(results)
.hasSize(25)
.extracting(WorkbasketSummary::getName)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
results =
workbasketService
@ -396,18 +353,21 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
.nameLike("%")
.accessIdsHavePermission(
WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.orderByName(desc)
.orderByName(DESCENDING)
.list();
assertEquals(13L, results.size());
assertThat(results).hasSize(13);
}
@WithAccessId(userName = "teamlead_1", groupNames = "group_1")
@Test
void testQueryWorkbasketByDomainLike() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainLike("DOMAIN_%").orderByDomain(asc).list();
workbasketService
.createWorkbasketQuery()
.domainLike("DOMAIN_%")
.orderByDomain(ASCENDING)
.list();
ArrayList<String> expectedIds =
new ArrayList<>(
@ -422,22 +382,25 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000009",
"WBI:100000000000000000000000000000000010",
"WBI:100000000000000000000000000000000012"));
assertEquals(10L, results.size());
for (String id : expectedIds) {
assertTrue(results.stream().anyMatch(wbSummary -> wbSummary.getId().equals(id)));
}
assertThat(results)
.hasSize(10)
.extracting(WorkbasketSummary::getId)
.containsOnly(toArray(expectedIds));
}
@WithAccessId(userName = "admin", groupNames = "group_1")
@Test
void testQueryWorkbasketByOwnerInOrderByDomainDesc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().ownerIn("owner0815").orderByDomain(desc).list();
workbasketService
.createWorkbasketQuery()
.ownerIn("owner0815")
.orderByDomain(DESCENDING)
.list();
assertEquals(2L, results.size());
assertEquals("WBI:100000000000000000000000000000000015", results.get(0).getId());
assertEquals("WBI:100000000000000000000000000000000001", results.get(1).getId());
assertThat(results).hasSize(2);
assertThat(results.get(0).getId()).isEqualTo("WBI:100000000000000000000000000000000015");
assertThat(results.get(1).getId()).isEqualTo("WBI:100000000000000000000000000000000001");
}
@WithAccessId(
@ -445,222 +408,218 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
groupNames = {"group_1"})
@Test
void testQueryForCustom1In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom1In("ABCQVW").list();
assertEquals(1, results.size());
assertEquals("WBI:100000000000000000000000000000000001", results.get(0).getId());
assertThat(results).hasSize(1);
assertThat(results.get(0).getId()).isEqualTo("WBI:100000000000000000000000000000000001");
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom1Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom1Like("custo%").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom2In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom2In("cust2", "custom2").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom2Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom2Like("cusTo%").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom3In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom3In("custom3").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom3Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom3Like("cu%").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom4In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom4In("custom4", "team").list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForCustom4Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().custom4Like("%u%").list();
assertEquals(5, results.size());
assertThat(results).hasSize(5);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevl1In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel1In("orgl1", "").list();
assertEquals(24, results.size());
assertThat(results).hasSize(24);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel1Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel1Like("%1").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel2In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel2In("abteilung").list();
assertEquals(1, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel2Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel2Like("ab%").list();
assertEquals(1, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel3In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel3In("orgl3").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel3Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel3Like("org%").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel4In() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel4In("team", "orgl4").list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrgLevel4Like() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orgLevel4Like("%").list();
assertEquals(25, results.size());
assertThat(results).hasSize(25);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByOrgLevel1Desc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel1(desc).list();
assertEquals("WBI:100000000000000000000000000000000007", results.get(0).getId());
workbasketService.createWorkbasketQuery().orderByOrgLevel1(DESCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getOrgLevel1)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByOrgLevel2Asc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel2(asc).list();
assertEquals(
"WBI:100000000000000000000000000000000007", results.get(results.size() - 3).getId());
workbasketService.createWorkbasketQuery().orderByOrgLevel2(ASCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getOrgLevel2)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByOrgLevel3Desc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel3(desc).list();
assertEquals("WBI:100000000000000000000000000000000007", results.get(0).getId());
workbasketService.createWorkbasketQuery().orderByOrgLevel3(DESCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getOrgLevel3)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByOrgLevel4Asc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByOrgLevel4(asc).list();
assertEquals(
"WBI:100000000000000000000000000000000012", results.get(results.size() - 3).getId());
workbasketService.createWorkbasketQuery().orderByOrgLevel4(ASCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getOrgLevel4)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByCustom1Asc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByCustom1(asc).list();
assertEquals(
"WBI:100000000000000000000000000000000015", results.get(results.size() - 4).getId());
workbasketService.createWorkbasketQuery().orderByCustom1(ASCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getCustom1)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByCustom2Desc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByCustom2(desc).list();
assertEquals("WBI:100000000000000000000000000000000014", results.get(0).getId());
workbasketService.createWorkbasketQuery().orderByCustom2(DESCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getCustom2)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByCustom3Asc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByCustom3(asc).list();
assertEquals(
"WBI:100000000000000000000000000000000015", results.get(results.size() - 4).getId());
workbasketService.createWorkbasketQuery().orderByCustom3(ASCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getCustom3)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
@WithAccessId(userName = "admin")
@Test
void testQueryForOrderByCustom4Desc() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().orderByCustom4(desc).list();
assertEquals("WBI:100000000000000000000000000000000006", results.get(0).getId());
workbasketService.createWorkbasketQuery().orderByCustom4(DESCENDING).list();
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketSummary::getCustom4)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER.reversed());
}
}

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

@ -1,16 +1,15 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static java.lang.String.CASE_INSENSITIVE_ORDER;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.workbasket.api.AccessItemQueryColumnName.ACCESS_ID;
import static pro.taskana.workbasket.api.AccessItemQueryColumnName.WORKBASKET_ID;
import static pro.taskana.workbasket.api.AccessItemQueryColumnName.WORKBASKET_KEY;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -38,21 +37,21 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<String> columnValueList =
workbasketService.createWorkbasketAccessItemQuery().listValues(WORKBASKET_ID, null);
assertNotNull(columnValueList);
assertEquals(24, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(24);
columnValueList =
workbasketService.createWorkbasketAccessItemQuery().listValues(ACCESS_ID, null);
assertNotNull(columnValueList);
assertEquals(9, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(9);
columnValueList =
workbasketService.createWorkbasketAccessItemQuery().listValues(WORKBASKET_KEY, null);
assertNotNull(columnValueList);
assertEquals(24, columnValueList.size());
assertThat(columnValueList).isNotNull();
assertThat(columnValueList).hasSize(24);
long countEntries = workbasketService.createWorkbasketAccessItemQuery().count();
assertTrue(columnValueList.size() < countEntries); // DISTINCT
assertThat(countEntries).isGreaterThan(columnValueList.size()); // DISTINCT
}
@WithAccessId(
@ -66,7 +65,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.createWorkbasketAccessItemQuery()
.accessIdIn("user_1_1", "group_1")
.list();
assertEquals(8L, results.size());
assertThat(results).hasSize(8);
}
@WithAccessId(userName = "dummy")
@ -74,13 +73,14 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
void testQueryAccessItemsForAccessIdsNotAuthorized() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService
.createWorkbasketAccessItemQuery()
.accessIdIn("user_1_1", "group_1")
.list());
ThrowingCallable call =
() -> {
workbasketService
.createWorkbasketAccessItemQuery()
.accessIdIn("user_1_1", "group_1")
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -97,9 +97,8 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.orderByWorkbasketId(SortDirection.DESCENDING);
List<WorkbasketAccessItem> results = query.list();
long count = query.count();
assertEquals(8L, results.size());
assertEquals(results.size(), count);
assertEquals("WAI:100000000000000000000000000000000003", results.get(0).getId());
assertThat(results).hasSize(8).size().isEqualTo(count);
assertThat(results.get(0).getId()).isEqualTo("WAI:100000000000000000000000000000000003");
}
@WithAccessId(
@ -116,7 +115,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
"WBI:100000000000000000000000000000000006",
"WBI:100000000000000000000000000000000002")
.list();
assertEquals(3L, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -127,7 +126,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService.createWorkbasketAccessItemQuery().workbasketKeyLike("GPK_KSC%").list();
assertEquals(4L, results.size());
assertThat(results).hasSize(4);
}
@WithAccessId(
@ -143,9 +142,9 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.workbasketKeyLike("GPK_KSC%")
.orderByWorkbasketKey(SortDirection.ASCENDING)
.list();
assertEquals(4L, results.size());
assertEquals("GPK_KSC", results.get(0).getWorkbasketKey());
assertEquals("GPK_KSC_2", results.get(3).getWorkbasketKey());
assertThat(results).hasSize(4);
assertThat(results.get(0).getWorkbasketKey()).isEqualTo("GPK_KSC");
assertThat(results.get(3).getWorkbasketKey()).isEqualTo("GPK_KSC_2");
}
@WithAccessId(
@ -159,7 +158,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.createWorkbasketAccessItemQuery()
.workbasketIdIn("WBI:100000000000000000000000000000000006")
.list();
assertEquals(3L, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -175,8 +174,8 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.orderByWorkbasketId(SortDirection.DESCENDING)
.orderByAccessId(SortDirection.ASCENDING)
.list();
assertEquals(3L, results.size());
assertEquals("WAI:100000000000000000000000000000000009", results.get(0).getId());
assertThat(results).hasSize(3);
assertThat(results.get(0).getId()).isEqualTo("WAI:100000000000000000000000000000000009");
}
@WithAccessId(userName = "admin")
@ -190,9 +189,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
};
List<WorkbasketAccessItem> results =
workbasketService.createWorkbasketAccessItemQuery().idIn(expectedIds).list();
for (String id : Arrays.asList(expectedIds)) {
assertTrue(results.stream().anyMatch(accessItem -> accessItem.getId().equals(id)));
}
assertThat(results).extracting(WorkbasketAccessItem::getId).containsOnly(expectedIds);
}
@WithAccessId(userName = "businessadmin")
@ -204,8 +201,9 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
.createWorkbasketAccessItemQuery()
.orderById(SortDirection.ASCENDING)
.list();
assertEquals("0000000000000000000000000000000000000900", results.get(0).getId());
assertEquals(
"WAI:100000000000000000000000000000000123", results.get(results.size() - 1).getId());
assertThat(results).hasSizeGreaterThan(2)
.extracting(WorkbasketAccessItem::getId)
.isSortedAccordingTo(CASE_INSENSITIVE_ORDER);
}
}

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

@ -1,13 +1,13 @@
package acceptance.workbasket;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -44,8 +44,8 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1")
.list();
assertEquals(1, results.size());
assertEquals("USER_1_1", results.get(0).getKey());
assertThat(results).hasSize(1);
assertThat(results.get(0).getKey()).isEqualTo("USER_1_1");
}
@WithAccessId(userName = "dummy")
@ -53,13 +53,14 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
void testQueryAllTransferTargetsForUserNotAuthorized() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Assertions.assertThrows(
NotAuthorizedException.class,
() ->
workbasketService
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1")
.list());
ThrowingCallable call =
() -> {
workbasketService
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1")
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(
@ -74,7 +75,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1", "group_1")
.list();
assertEquals(6, results.size());
assertThat(results).hasSize(6);
}
@WithAccessId(
@ -90,8 +91,8 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.accessIdsHavePermission(WorkbasketPermission.APPEND, "user_1_1", "group_1")
.orderByName(asc)
.list();
assertEquals(6, results.size());
assertEquals("GPK_KSC_1", results.get(0).getKey());
assertThat(results).hasSize(6);
assertThat(results.get(0).getKey()).isEqualTo("GPK_KSC_1");
}
@WithAccessId(
@ -108,8 +109,8 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.orderByName(desc)
.orderByKey(asc)
.list();
assertEquals(6, results.size());
assertEquals("USER_2_2", results.get(0).getKey());
assertThat(results).hasSize(6);
assertThat(results.get(0).getKey()).isEqualTo("USER_2_2");
}
@WithAccessId(
@ -124,10 +125,10 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.accessIdsHavePermission(WorkbasketPermission.DISTRIBUTE, "user_1_1", "group_1")
.list();
assertEquals(2, results.size());
assertThat(results).hasSize(2);
List<String> keys = new ArrayList<>(Arrays.asList("GPK_KSC_1", "USER_1_1"));
for (WorkbasketSummary wb : results) {
assertTrue(keys.contains(wb.getKey()));
assertThat(keys.contains(wb.getKey())).isTrue();
}
}
@ -142,7 +143,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.callerHasPermission(WorkbasketPermission.APPEND)
.list();
assertEquals(6, results.size());
assertThat(results).hasSize(6);
}
@WithAccessId(userName = "user_1_1")
@ -154,7 +155,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.callerHasPermission(WorkbasketPermission.READ)
.list();
assertEquals(1, results.size());
assertThat(results).hasSize(1);
}
@WithAccessId(
@ -168,7 +169,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.callerHasPermission(WorkbasketPermission.OPEN)
.list();
assertEquals(3, results.size());
assertThat(results).hasSize(3);
}
@WithAccessId(userName = "admin")
@ -180,6 +181,6 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.callerHasPermission(WorkbasketPermission.OPEN)
.list();
assertEquals(25, results.size());
assertThat(results).hasSize(25);
}
}

31
lib/taskana-core/src/test/java/acceptance/workbasket/QueryWorkbasketsWithPaginationAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.workbasket;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -29,7 +28,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results).hasSize(5);
}
@WithAccessId(
@ -40,7 +39,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list(5, 5);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
}
@WithAccessId(
@ -53,15 +52,15 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
// both will be 0, working
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list(-1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// limit will be 0
results = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list(1, -3);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// offset will be 0
results = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list(-1, 3);
assertThat(results.size(), equalTo(3));
assertThat(results).hasSize(3);
}
@WithAccessId(
@ -79,7 +78,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
// Getting full page
pageNumber = 4;
@ -89,7 +88,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(1));
assertThat(results).hasSize(1);
// Getting last results on 1 big page
pageNumber = 1;
@ -99,7 +98,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(9));
assertThat(results).hasSize(9);
// Getting last results on multiple pages
pageNumber = 2;
@ -109,7 +108,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(4));
assertThat(results).hasSize(4);
}
@WithAccessId(
@ -127,7 +126,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative size will be 0 = 0 results
pageNumber = 2;
@ -137,7 +136,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(0));
assertThat(results).isEmpty();
// Negative page = first page
pageNumber = -1;
@ -147,7 +146,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
.createWorkbasketQuery()
.domainIn("DOMAIN_A")
.listPage(pageNumber, pageSize);
assertThat(results.size(), equalTo(9));
assertThat(results).hasSize(9);
}
@WithAccessId(
@ -157,7 +156,7 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
void testCountOfWorkbasketQuery() {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
long count = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").count();
assertThat(count, equalTo(9L));
assertThat(count).isEqualTo(9L);
}
@WithAccessId(
@ -168,6 +167,6 @@ class QueryWorkbasketsWithPaginationAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> result =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list();
assertThat(result.size(), equalTo(9));
assertThat(result).hasSize(9);
}
}

8
lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAuthorizations2AccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.workbasket;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
@ -31,13 +30,14 @@ public class UpdateWorkbasketAuthorizations2AccTest extends AbstractAccTest {
final String wbId = "WBI:100000000000000000000000000000000004";
List<WorkbasketAccessItem> accessItems = workbasketService.getWorkbasketAccessItems(wbId);
int countBefore = accessItems.size();
assertThat(3, equalTo(countBefore));
assertThat(countBefore).isEqualTo(3);
workbasketService.setWorkbasketAccessItems(wbId, new ArrayList<>());
List<WorkbasketAccessItem> updatedAccessItems =
workbasketService.getWorkbasketAccessItems(wbId);
int countAfter = updatedAccessItems.size();
assertThat(0, equalTo(countAfter));
assertThat(countAfter).isEqualTo(0);
}
}

111
lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAuthorizationsAccTest.java
View File

@ -1,19 +1,13 @@
package acceptance.workbasket;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -69,13 +63,13 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
WorkbasketAccessItem updatedItem =
items.stream().filter(t -> newItem.getId().equals(t.getId())).findFirst().orElse(null);
assertNotNull(updatedItem);
assertEquals("Rojas, Miguel", updatedItem.getAccessName());
assertFalse(updatedItem.isPermAppend());
assertTrue(updatedItem.isPermRead());
assertTrue(updatedItem.isPermCustom11());
assertTrue(updatedItem.isPermCustom1());
assertFalse(updatedItem.isPermCustom2());
assertThat(updatedItem).isNotNull();
assertThat(updatedItem.getAccessName()).isEqualTo("Rojas, Miguel");
assertThat(updatedItem.isPermAppend()).isFalse();
assertThat(updatedItem.isPermRead()).isTrue();
assertThat(updatedItem.isPermCustom11()).isTrue();
assertThat(updatedItem.isPermCustom1()).isTrue();
assertThat(updatedItem.isPermCustom2()).isFalse();
}
@WithAccessId(
@ -99,26 +93,32 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
accessItemCreated.setPermAppend(false);
((WorkbasketAccessItemImpl) accessItemCreated).setAccessId("willi");
Assertions.assertThrows(
InvalidArgumentException.class,
() -> workbasketService.updateWorkbasketAccessItem(accessItemCreated),
"InvalidArgumentException was expected because access id was changed");
ThrowingCallable call =
() -> {
workbasketService.updateWorkbasketAccessItem(accessItemCreated);
};
assertThatThrownBy(call)
.describedAs("InvalidArgumentException was expected because access id was changed")
.isInstanceOf(InvalidArgumentException.class);
((WorkbasketAccessItemImpl) accessItemCreated).setAccessId("user1");
WorkbasketAccessItem accessItemUpdated =
workbasketService.updateWorkbasketAccessItem(accessItemCreated);
assertFalse(accessItemUpdated.isPermAppend());
assertTrue(accessItemUpdated.isPermRead());
assertTrue(accessItemUpdated.isPermCustom11());
assertTrue(accessItemUpdated.isPermCustom1());
assertFalse(accessItemUpdated.isPermCustom2());
assertThat(accessItemUpdated.isPermAppend()).isFalse();
assertThat(accessItemUpdated.isPermRead()).isTrue();
assertThat(accessItemUpdated.isPermCustom11()).isTrue();
assertThat(accessItemUpdated.isPermCustom1()).isTrue();
assertThat(accessItemUpdated.isPermCustom2()).isFalse();
((WorkbasketAccessItemImpl) accessItemUpdated).setWorkbasketId("2");
Assertions.assertThrows(
InvalidArgumentException.class,
() -> workbasketService.updateWorkbasketAccessItem(accessItemUpdated),
"InvalidArgumentException was expected because key was changed");
call =
() -> {
workbasketService.updateWorkbasketAccessItem(accessItemUpdated);
};
assertThatThrownBy(call)
.describedAs("InvalidArgumentException was expected because key was changed")
.isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(
@ -142,8 +142,8 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
Task createdTask = taskService.createTask(newTask);
List<TaskSummary> tasks =
taskService.createTaskQuery().workbasketKeyDomainIn(new KeyDomain(wbKey, wbDomain)).list();
assertEquals(1, tasks.size());
assertThat(createdTask, not(equalTo(null)));
assertThat(tasks).hasSize(1);
assertThat(createdTask).isNotNull();
List<WorkbasketAccessItem> accessItems =
workbasketService.getWorkbasketAccessItems("WBI:100000000000000000000000000000000008");
@ -153,17 +153,18 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
.findFirst()
.orElse(null);
assertNotNull(theAccessItem);
assertThat(theAccessItem).isNotNull();
theAccessItem.setPermOpen(false);
workbasketService.updateWorkbasketAccessItem(theAccessItem);
Assertions.assertThrows(
NotAuthorizedToQueryWorkbasketException.class,
() ->
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain(wbKey, wbDomain))
.list());
ThrowingCallable call =
() -> {
taskService
.createTaskQuery()
.workbasketKeyDomainIn(new KeyDomain(wbKey, wbDomain))
.list();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedToQueryWorkbasketException.class);
}
@WithAccessId(
@ -193,17 +194,17 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
List<WorkbasketAccessItem> updatedAccessItems =
workbasketService.getWorkbasketAccessItems(wbId);
int countAfter = updatedAccessItems.size();
assertThat(countAfter, equalTo(countBefore));
assertThat(countAfter).isEqualTo(countBefore);
item0 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId0)).findFirst().get();
assertFalse(item0.isPermAppend());
assertFalse(item0.isPermOpen());
assertFalse(item0.isPermTransfer());
assertThat(item0.isPermAppend()).isFalse();
assertThat(item0.isPermOpen()).isFalse();
assertThat(item0.isPermTransfer()).isFalse();
item1 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId1)).findFirst().get();
assertFalse(item1.isPermAppend());
assertFalse(item1.isPermOpen());
assertFalse(item1.isPermTransfer());
assertThat(item1.isPermAppend()).isFalse();
assertThat(item1.isPermOpen()).isFalse();
assertThat(item1.isPermTransfer()).isFalse();
}
@WithAccessId(
@ -234,14 +235,14 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
List<WorkbasketAccessItem> updatedAccessItems =
workbasketService.getWorkbasketAccessItems(wbId);
int countAfter = updatedAccessItems.size();
assertEquals((countBefore + 1), countAfter);
assertThat(countAfter).isEqualTo((countBefore + 1));
item0 = updatedAccessItems.stream().filter(i -> i.getId().equals(updateId0)).findFirst().get();
assertFalse(item0.isPermAppend());
assertFalse(item0.isPermOpen());
assertFalse(item0.isPermTransfer());
assertFalse(item0.isPermAppend());
assertFalse(item0.isPermTransfer());
assertThat(item0.isPermAppend()).isFalse();
assertThat(item0.isPermOpen()).isFalse();
assertThat(item0.isPermTransfer()).isFalse();
assertThat(item0.isPermAppend()).isFalse();
assertThat(item0.isPermTransfer()).isFalse();
}
@WithAccessId(
@ -261,7 +262,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
List<WorkbasketAccessItem> accessList = new ArrayList<>(originalList);
WorkbasketAccessItem newItem = workbasketService.newWorkbasketAccessItem(wbId, "group_1");
accessList.add(newItem);
assertNotEquals(originalList, accessList);
assertThat(accessList).isNotEqualTo(originalList);
workbasketService.setWorkbasketAccessItems(wbId, accessList);
List<WorkbasketAccessItem> modifiedList =
@ -275,7 +276,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
new ArrayList<>(workbasketService.getWorkbasketAccessItems(wbId));
// with DB2 V 11, the lists are sorted differently...
assertEquals(new HashSet<>(originalList), new HashSet<>(listEqualToOriginal));
assertThat(new HashSet<>(listEqualToOriginal)).isEqualTo(new HashSet<>(originalList));
}
@WithAccessId(
@ -292,7 +293,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
final long accessIdCountAfter =
workbasketService.createWorkbasketAccessItemQuery().accessIdIn(accessId).count();
assertTrue(accessIdCountBefore > accessIdCountAfter);
assertThat(accessIdCountBefore > accessIdCountAfter).isTrue();
}
@WithAccessId(

27
lib/taskana-core/src/test/java/acceptance/workbasket/WorkbasketQueryWithOrderedPaginationAccTest.java
View File

@ -1,7 +1,6 @@
package acceptance.workbasket;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.util.List;
@ -29,15 +28,15 @@ class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").orderByKey(asc).list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("GPK_KSC"));
assertThat(results.get(4).getKey(), equalTo("TEAMLEAD_2"));
assertThat(results).hasSize(5);
assertThat(results.get(0).getKey()).isEqualTo("GPK_KSC");
assertThat(results.get(4).getKey()).isEqualTo("TEAMLEAD_2");
results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").orderByKey(desc).list(0, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("USER_2_2"));
assertThat(results.get(4).getKey(), equalTo("TPK_VIP"));
assertThat(results).hasSize(5);
assertThat(results.get(0).getKey()).isEqualTo("USER_2_2");
assertThat(results.get(4).getKey()).isEqualTo("TPK_VIP");
}
@Test
@ -48,14 +47,14 @@ class WorkbasketQueryWithOrderedPaginationAccTest extends AbstractAccTest {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").orderByKey(asc).list(5, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("TPK_VIP"));
assertThat(results.get(4).getKey(), equalTo("USER_2_2"));
assertThat(results).hasSize(5);
assertThat(results.get(0).getKey()).isEqualTo("TPK_VIP");
assertThat(results.get(4).getKey()).isEqualTo("USER_2_2");
results =
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").orderByKey(desc).list(5, 5);
assertThat(results.size(), equalTo(5));
assertThat(results.get(0).getKey(), equalTo("TEAMLEAD_2"));
assertThat(results.get(4).getKey(), equalTo("GPK_KSC"));
assertThat(results).hasSize(5);
assertThat(results.get(0).getKey()).isEqualTo("TEAMLEAD_2");
assertThat(results.get(4).getKey()).isEqualTo("GPK_KSC");
}
}

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

@ -9,7 +9,6 @@ import static org.junit.jupiter.api.DynamicTest.dynamicTest;
import com.tngtech.archunit.core.domain.JavaClasses;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import com.tngtech.archunit.core.importer.ImportOption.DoNotIncludeTests;
import com.tngtech.archunit.lang.ArchRule;
import java.util.regex.Pattern;
import java.util.stream.Stream;
@ -29,10 +28,7 @@ class ArchitectureTest {
@BeforeAll
static void init() throws ClassNotFoundException {
// time intensive operation should only be done once
importedClasses =
new ClassFileImporter()
.withImportOption(new DoNotIncludeTests())
.importPackages("pro.taskana");
importedClasses = new ClassFileImporter().importPackages("pro.taskana", "acceptance");
}
@Test
@ -168,4 +164,15 @@ class ArchitectureTest {
ArchRule myRule = slices().matching("pro.taskana.(*)..").should().notDependOnEachOther();
myRule.check(importedClasses);
}
@Test
void classesShouldNotUseJunit5Assertions() {
ArchRule rule =
noClasses()
.should()
.dependOnClassesThat()
.haveFullyQualifiedName(org.junit.jupiter.api.Assertions.class.getName())
.because("we consistently want to use assertj in our tests");
rule.check(importedClasses);
}
}

5
lib/taskana-core/src/test/java/pro/taskana/PojoTest.java
View File

@ -1,5 +1,7 @@
package pro.taskana;
import static org.assertj.core.api.Assertions.assertThat;
import com.openpojo.reflection.impl.PojoClassFactory;
import com.openpojo.validation.ValidatorBuilder;
import com.openpojo.validation.rule.Rule;
@ -17,7 +19,6 @@ import java.util.stream.Collectors;
import java.util.stream.Stream;
import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
@ -27,7 +28,7 @@ class PojoTest {
@Test
void testsThatPojoClassesAreFound() {
Assertions.assertTrue(getPojoClasses().count() > 0);
assertThat(getPojoClasses().count() > 0).isTrue();
}
@TestFactory

8
lib/taskana-core/src/test/java/pro/taskana/classification/internal/ClassificationQueryImplTest.java
View File

@ -1,6 +1,6 @@
package pro.taskana.classification.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ -43,7 +43,7 @@ class ClassificationQueryImplTest {
.priorityIn(1, 2)
.parentIdIn("superId")
.list();
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -58,7 +58,7 @@ class ClassificationQueryImplTest {
.priorityIn(1, 2)
.parentIdIn("superId")
.list(1, 1);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -73,6 +73,6 @@ class ClassificationQueryImplTest {
.priorityIn(1, 2)
.parentIdIn("superId")
.single();
assertNotNull(result);
assertThat(result).isNotNull();
}
}

43
lib/taskana-core/src/test/java/pro/taskana/classification/internal/ClassificationServiceImplIntAutoCommitTest.java
View File

@ -1,8 +1,6 @@
package pro.taskana.classification.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.SQLException;
import java.time.Instant;
@ -12,7 +10,6 @@ import java.time.LocalTime;
import java.time.ZoneId;
import java.util.List;
import javax.sql.DataSource;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -41,14 +38,12 @@ import pro.taskana.sampledata.SampleDataGenerator;
*/
class ClassificationServiceImplIntAutoCommitTest {
private static SampleDataGenerator sampleDataGenerator;
private static TaskanaEngineConfiguration taskanaEngineConfiguration;
private ClassificationService classificationService;
private SampleDataGenerator sampleDataGenerator;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
@BeforeAll
void beforeAll() throws SQLException {
static void beforeAll() throws SQLException {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
@ -62,10 +57,6 @@ class ClassificationServiceImplIntAutoCommitTest {
classificationService = taskanaEngine.getClassificationService();
TaskanaEngineImpl taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
}
@AfterEach
void teardown() {
sampleDataGenerator.clearDb();
}
@ -81,7 +72,7 @@ class ClassificationServiceImplIntAutoCommitTest {
classification2.setParentId(classification0.getId());
classificationService.createClassification(classification2);
assertEquals(2 + 1, classificationService.createClassificationQuery().list().size());
assertThat(classificationService.createClassificationQuery().list()).hasSize(2 + 1);
}
@Test
@ -100,7 +91,7 @@ class ClassificationServiceImplIntAutoCommitTest {
classification =
classificationService.getClassification(
classification.getKey(), classification.getDomain());
assertThat(description, equalTo(classification.getDescription()));
assertThat(classification.getDescription()).isEqualTo(description);
}
@Test
@ -118,7 +109,7 @@ class ClassificationServiceImplIntAutoCommitTest {
.createdWithin(today())
.list();
assertEquals(1, list.size());
assertThat(list).hasSize(1);
}
@Test
@ -134,15 +125,15 @@ class ClassificationServiceImplIntAutoCommitTest {
List<ClassificationSummary> list =
classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(1, list.size());
assertThat(list).hasSize(1);
classificationService.updateClassification(classification);
list = classificationService.createClassificationQuery().list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
List<ClassificationSummary> allClassifications =
classificationService.createClassificationQuery().list();
assertEquals(2, allClassifications.size());
assertThat(allClassifications).hasSize(2);
}
@Test
@ -163,19 +154,19 @@ class ClassificationServiceImplIntAutoCommitTest {
List<ClassificationSummary> list =
classificationService.createClassificationQuery().parentIdIn("").list();
assertEquals(3, list.size());
assertThat(list).hasSize(3);
list = classificationService.createClassificationQuery().list();
assertEquals(4, list.size());
assertThat(list).hasSize(4);
List<ClassificationSummary> listAll = classificationService.createClassificationQuery().list();
list = classificationService.createClassificationQuery().list();
assertEquals(listAll.size(), list.size());
assertThat(list).hasSize(listAll.size());
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
list = classificationService.createClassificationQuery().createdWithin(today()).list();
assertEquals(4, list.size());
assertThat(list).hasSize(4);
list =
classificationService
@ -183,10 +174,10 @@ class ClassificationServiceImplIntAutoCommitTest {
.domainIn("DOMAIN_C")
.validInDomainEquals(false)
.list();
assertEquals(0, list.size());
assertThat(list).isEmpty();
list = classificationService.createClassificationQuery().list();
assertEquals(4, list.size());
assertThat(list).hasSize(4);
}
private TimeInterval today() {

65
lib/taskana-core/src/test/java/pro/taskana/classification/internal/ClassificationServiceImplIntExplicitTest.java
View File

@ -1,9 +1,7 @@
package pro.taskana.classification.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsNot.not;
import static org.hamcrest.core.StringStartsWith.startsWith;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Connection;
import java.sql.SQLException;
@ -14,9 +12,8 @@ import java.time.LocalTime;
import java.time.ZoneId;
import java.util.List;
import javax.sql.DataSource;
import org.hamcrest.core.IsEqual;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -102,14 +99,14 @@ public class ClassificationServiceImplIntExplicitTest {
connection.commit();
Classification actualClassification =
classificationService.getClassification(key, "DOMAIN_B");
assertThat(actualClassification, not(IsEqual.equalTo(null)));
assertThat(actualClassification.getCreated(), not(IsEqual.equalTo(null)));
assertThat(actualClassification.getId(), not(IsEqual.equalTo(null)));
assertThat(actualClassification.getKey(), IsEqual.equalTo(key));
assertThat(actualClassification.getDomain(), IsEqual.equalTo("DOMAIN_B"));
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
assertThat(actualClassification).isNotNull();
assertThat(actualClassification.getCreated()).isNotNull();
assertThat(actualClassification.getId()).isNotNull();
assertThat(actualClassification.getKey()).isEqualTo(key);
assertThat(actualClassification.getDomain()).isEqualTo("DOMAIN_B");
assertThat(actualClassification.getId()).startsWith(ID_PREFIX_CLASSIFICATION);
Classification masterResult = classificationService.getClassification(key, "");
assertThat(masterResult, not(IsEqual.equalTo(null)));
assertThat(masterResult).isNotNull();
// invalid serviceLevel
ClassificationImpl expectedClassificationCreated =
@ -118,12 +115,14 @@ public class ClassificationServiceImplIntExplicitTest {
expectedClassificationCreated.setKey("");
expectedClassificationCreated.setServiceLevel("ASAP");
Assertions.assertThrows(
InvalidArgumentException.class,
ThrowingCallable call =
() -> {
classificationService.createClassification(expectedClassificationCreated);
},
"Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
};
assertThatThrownBy(call)
.describedAs(
"Should have thrown IllegalArgumentException, because ServiceLevel is invalid.")
.isInstanceOf(InvalidArgumentException.class);
connection.commit();
}
@ -143,7 +142,7 @@ public class ClassificationServiceImplIntExplicitTest {
classification2.setParentId(classification0.getId());
classificationService.createClassification(classification2);
assertEquals(2 + 1, classificationService.createClassificationQuery().list().size());
assertThat(classificationService.createClassificationQuery().list()).hasSize(2 + 1);
connection.commit();
}
}
@ -168,7 +167,7 @@ public class ClassificationServiceImplIntExplicitTest {
classification =
classificationService.getClassification(
classification.getKey(), classification.getDomain());
assertThat(classification.getDescription(), IsEqual.equalTo(updatedDescription));
assertThat(classification.getDescription()).isEqualTo(updatedDescription);
}
}
@ -186,7 +185,7 @@ public class ClassificationServiceImplIntExplicitTest {
.validInDomainEquals(Boolean.TRUE)
.createdWithin(today())
.list();
assertEquals(1, list.size());
assertThat(list).hasSize(1);
}
}
@ -204,21 +203,21 @@ public class ClassificationServiceImplIntExplicitTest {
classification = classificationService.updateClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery().list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(1, list.size());
assertThat(list).hasSize(1);
classification =
classificationService.getClassification(
classification.getKey(), classification.getDomain());
assertThat(classification.getDescription(), IsEqual.equalTo("description"));
assertThat(classification.getDescription()).isEqualTo("description");
classification = classificationService.updateClassification(classification);
list = classificationService.createClassificationQuery().list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
List<ClassificationSummary> allClassifications =
classificationService.createClassificationQuery().list();
assertEquals(2, allClassifications.size());
assertThat(allClassifications).hasSize(2);
connection.commit();
}
}
@ -241,33 +240,33 @@ public class ClassificationServiceImplIntExplicitTest {
List<ClassificationSummary> list =
classificationService.createClassificationQuery().parentIdIn("").list();
assertEquals(3, list.size());
assertThat(list).hasSize(3);
list = classificationService.createClassificationQuery().list();
assertEquals(4, list.size());
assertThat(list).hasSize(4);
connection.commit();
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
list = classificationService.createClassificationQuery().createdWithin(today()).list();
assertEquals(4, list.size());
assertThat(list).hasSize(4);
list =
classificationService
.createClassificationQuery()
.domainIn("DOMAIN_C")
.validInDomainEquals(false)
.list();
assertEquals(0, list.size());
assertThat(list).isEmpty();
list =
classificationService.createClassificationQuery().keyIn(classification1.getKey()).list();
assertEquals(2, list.size());
assertThat(list).hasSize(2);
list =
classificationService
.createClassificationQuery()
.parentIdIn(classification.getId())
.list();
assertEquals(1, list.size());
assertThat(list.get(0).getKey(), IsEqual.equalTo(classification1.getKey()));
assertThat(list).hasSize(1);
assertThat(list.get(0).getKey()).isEqualTo(classification1.getKey());
connection.commit();
}
}

24
lib/taskana-core/src/test/java/pro/taskana/classification/internal/ClassificationServiceImplTest.java
View File

@ -1,11 +1,11 @@
package pro.taskana.classification.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
@ -46,17 +46,15 @@ class ClassificationServiceImplTest {
@Test
void testThrowExceptionIdIfClassificationIsCreatedWithAnExplicitId() {
when(internalTaskanaEngineMock.getEngine()).thenReturn(taskanaEngineMock);
InvalidArgumentException invalidArgumentException =
Assertions.assertThrows(
InvalidArgumentException.class,
() -> {
Classification classification = createDummyClassification();
when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
cutSpy.createClassification(classification);
});
assertEquals(
invalidArgumentException.getMessage(), "ClassificationId should be null on creation");
ThrowingCallable call =
() -> {
Classification classification = createDummyClassification();
when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
cutSpy.createClassification(classification);
};
assertThatThrownBy(call)
.isInstanceOf(InvalidArgumentException.class)
.hasMessage("ClassificationId should be null on creation");
}
private Classification createDummyClassification() {

3
lib/taskana-core/src/test/java/pro/taskana/classification/api/models/ClassificationModelsCloneTest.java → lib/taskana-core/src/test/java/pro/taskana/classification/internal/models/ClassificationModelsCloneTest.java
View File

@ -1,9 +1,10 @@
package pro.taskana.classification.api.models;
package pro.taskana.classification.internal.models;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.classification.internal.models.ClassificationSummaryImpl;

5
lib/taskana-core/src/test/java/pro/taskana/common/internal/TaskanaEngineTestConfiguration.java
View File

@ -177,7 +177,10 @@ public final class TaskanaEngineTestConfiguration {
// ds.setUser("sa");
String jdbcDriver = "org.h2.Driver";
String jdbcUrl = "jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0";
String jdbcUrl =
"jdbc:h2:mem:taskana;IGNORECASE=TRUE;LOCK_MODE=0;"
+ "INIT=CREATE SCHEMA IF NOT EXISTS TASKANA\\;"
+ "SET COLLATION DEFAULT_de_DE ";
String dbUserName = "sa";
String dbPassword = "sa";
PooledDataSource ds =

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

@ -1,6 +1,6 @@
package pro.taskana.common.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.SQLException;
import javax.sql.DataSource;
@ -20,6 +20,6 @@ class TaskanaEngineTestConfigurationTest {
TaskanaEngine te = taskEngineConfiguration.buildTaskanaEngine();
assertNotNull(te);
assertThat(te).isNotNull();
}
}

98
lib/taskana-core/src/test/java/pro/taskana/common/internal/util/WorkingDaysToDaysConverterTest.java
View File

@ -1,18 +1,15 @@
package pro.taskana.common.internal.util;
import static java.util.Collections.singletonList;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.common.internal.util.WorkingDaysToDaysConverter.getEasterSunday;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Arrays;
import java.util.List;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
/** Test for the WorkingDaysToDaysConverter. */
class WorkingDaysToDaysConverterTest {
@ -31,43 +28,43 @@ class WorkingDaysToDaysConverterTest {
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(thursday0201);
long days = converter.convertWorkingDaysToDays(thursday0201, -7); // = tuesday (sat + sun)
assertEquals(-9, days);
assertThat(days).isEqualTo(-9);
days = converter.convertWorkingDaysToDays(thursday0201, -6); // = wednesday (sat + sun)
assertEquals(-8, days);
assertThat(days).isEqualTo(-8);
days = converter.convertWorkingDaysToDays(thursday0201, -5); // = thursday (sat + sun)
assertEquals(-7, days);
assertThat(days).isEqualTo(-7);
days = converter.convertWorkingDaysToDays(thursday0201, -4); // = friday
assertEquals(-6, days);
assertThat(days).isEqualTo(-6);
days = converter.convertWorkingDaysToDays(thursday0201, -3); // monday
assertEquals(-3, days);
assertThat(days).isEqualTo(-3);
days = converter.convertWorkingDaysToDays(thursday0201, -2); // tuesday
assertEquals(-2, days);
assertThat(days).isEqualTo(-2);
days = converter.convertWorkingDaysToDays(thursday0201, -1); // wednesday
assertEquals(-1, days);
assertThat(days).isEqualTo(-1);
days = converter.convertWorkingDaysToDays(thursday0201, 0); // = thursday
assertEquals(0, days);
assertThat(days).isEqualTo(0);
days = converter.convertWorkingDaysToDays(thursday0201, 1); // fri
assertEquals(1, days);
assertThat(days).isEqualTo(1);
days = converter.convertWorkingDaysToDays(thursday0201, 2); // mon
assertEquals(4, days);
assertThat(days).isEqualTo(4);
days = converter.convertWorkingDaysToDays(thursday0201, 3); // tues
assertEquals(5, days);
assertThat(days).isEqualTo(5);
days = converter.convertWorkingDaysToDays(thursday0201, 4); // we
assertEquals(6, days);
assertThat(days).isEqualTo(6);
days = converter.convertWorkingDaysToDays(thursday0201, 5); // thurs
assertEquals(7, days);
assertThat(days).isEqualTo(7);
days = converter.convertWorkingDaysToDays(thursday0201, 6); // fri
assertEquals(8, days);
assertThat(days).isEqualTo(8);
days = converter.convertWorkingDaysToDays(thursday0201, 7); // mon
assertEquals(11, days);
assertThat(days).isEqualTo(11);
days = converter.convertWorkingDaysToDays(thursday0201, 8); // tue
assertEquals(12, days);
assertThat(days).isEqualTo(12);
days = converter.convertWorkingDaysToDays(thursday0201, 9); // we
assertEquals(13, days);
assertThat(days).isEqualTo(13);
days = converter.convertWorkingDaysToDays(thursday0201, 10); // thu
assertEquals(14, days);
assertThat(days).isEqualTo(14);
days = converter.convertWorkingDaysToDays(thursday0201, 11); // fri
assertEquals(15, days);
assertThat(days).isEqualTo(15);
}
@Test
@ -76,51 +73,50 @@ class WorkingDaysToDaysConverterTest {
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(thursday0201);
Instant gruenDonnerstag2018 = Instant.parse("2018-03-29T01:00:00.000Z");
long days = converter.convertWorkingDaysToDays(gruenDonnerstag2018, 0);
assertEquals(0, days);
assertThat(days).isEqualTo(0);
days = converter.convertWorkingDaysToDays(gruenDonnerstag2018, 1); // Karfreitag
assertEquals(5, days); // osterdienstag
assertThat(days).isEqualTo(5); // osterdienstag
days = converter.convertWorkingDaysToDays(gruenDonnerstag2018, 2); // Karfreitag
assertEquals(6, days); // ostermittwoch
assertThat(days).isEqualTo(6); // ostermittwoch
}
@Test
void testConvertWorkingDaysToDaysForHolidays() throws InvalidArgumentException {
List<TimeIntervalColumnHeader> reportItems = singletonList(new TimeIntervalColumnHeader(0));
Instant thursday0201 = Instant.parse("2018-02-01T07:00:00.000Z");
WorkingDaysToDaysConverter converter = WorkingDaysToDaysConverter.initialize(thursday0201);
Instant freitag0427 = Instant.parse("2018-04-27T19:00:00.000Z");
long days = converter.convertWorkingDaysToDays(freitag0427, 0);
assertEquals(0, days);
assertThat(days).isEqualTo(0);
days = converter.convertWorkingDaysToDays(freitag0427, 1);
assertEquals(3, days); // 30.4.
assertThat(days).isEqualTo(3); // 30.4.
days = converter.convertWorkingDaysToDays(freitag0427, 2);
assertEquals(5, days); // 2.5.
assertThat(days).isEqualTo(5); // 2.5.
}
@Test
void testGetEasterSunday() {
assertEquals(LocalDate.of(2018, 4, 1), getEasterSunday(2018));
assertEquals(LocalDate.of(2019, 4, 21), getEasterSunday(2019));
assertEquals(LocalDate.of(2020, 4, 12), getEasterSunday(2020));
assertEquals(LocalDate.of(2021, 4, 4), getEasterSunday(2021));
assertEquals(LocalDate.of(2022, 4, 17), getEasterSunday(2022));
assertEquals(LocalDate.of(2023, 4, 9), getEasterSunday(2023));
assertEquals(LocalDate.of(2024, 3, 31), getEasterSunday(2024));
assertEquals(LocalDate.of(2025, 4, 20), getEasterSunday(2025));
assertEquals(LocalDate.of(2026, 4, 5), getEasterSunday(2026));
assertEquals(LocalDate.of(2027, 3, 28), getEasterSunday(2027));
assertEquals(LocalDate.of(2028, 4, 16), getEasterSunday(2028));
assertEquals(LocalDate.of(2029, 4, 1), getEasterSunday(2029));
assertEquals(LocalDate.of(2030, 4, 21), getEasterSunday(2030));
assertEquals(LocalDate.of(2031, 4, 13), getEasterSunday(2031));
assertEquals(LocalDate.of(2032, 3, 28), getEasterSunday(2032));
assertEquals(LocalDate.of(2033, 4, 17), getEasterSunday(2033));
assertEquals(LocalDate.of(2034, 4, 9), getEasterSunday(2034));
assertEquals(LocalDate.of(2035, 3, 25), getEasterSunday(2035));
assertEquals(LocalDate.of(2040, 4, 1), getEasterSunday(2040));
assertEquals(LocalDate.of(2050, 4, 10), getEasterSunday(2050));
assertEquals(LocalDate.of(2100, 3, 28), getEasterSunday(2100));
assertThat(getEasterSunday(2018)).isEqualTo(LocalDate.of(2018, 4, 1));
assertThat(getEasterSunday(2019)).isEqualTo(LocalDate.of(2019, 4, 21));
assertThat(getEasterSunday(2020)).isEqualTo(LocalDate.of(2020, 4, 12));
assertThat(getEasterSunday(2021)).isEqualTo(LocalDate.of(2021, 4, 4));
assertThat(getEasterSunday(2022)).isEqualTo(LocalDate.of(2022, 4, 17));
assertThat(getEasterSunday(2023)).isEqualTo(LocalDate.of(2023, 4, 9));
assertThat(getEasterSunday(2024)).isEqualTo(LocalDate.of(2024, 3, 31));
assertThat(getEasterSunday(2025)).isEqualTo(LocalDate.of(2025, 4, 20));
assertThat(getEasterSunday(2026)).isEqualTo(LocalDate.of(2026, 4, 5));
assertThat(getEasterSunday(2027)).isEqualTo(LocalDate.of(2027, 3, 28));
assertThat(getEasterSunday(2028)).isEqualTo(LocalDate.of(2028, 4, 16));
assertThat(getEasterSunday(2029)).isEqualTo(LocalDate.of(2029, 4, 1));
assertThat(getEasterSunday(2030)).isEqualTo(LocalDate.of(2030, 4, 21));
assertThat(getEasterSunday(2031)).isEqualTo(LocalDate.of(2031, 4, 13));
assertThat(getEasterSunday(2032)).isEqualTo(LocalDate.of(2032, 3, 28));
assertThat(getEasterSunday(2033)).isEqualTo(LocalDate.of(2033, 4, 17));
assertThat(getEasterSunday(2034)).isEqualTo(LocalDate.of(2034, 4, 9));
assertThat(getEasterSunday(2035)).isEqualTo(LocalDate.of(2035, 3, 25));
assertThat(getEasterSunday(2040)).isEqualTo(LocalDate.of(2040, 4, 1));
assertThat(getEasterSunday(2050)).isEqualTo(LocalDate.of(2050, 4, 10));
assertThat(getEasterSunday(2100)).isEqualTo(LocalDate.of(2100, 3, 28));
}
}

29
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/CategoryReportBuilderImplTest.java
View File

@ -1,7 +1,6 @@
package pro.taskana.monitor.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
@ -110,9 +109,9 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(actualResult.getRow("EXTERN").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getTotalValue());
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -173,10 +172,10 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(actualResult.getRow("EXTERN").getTotalValue(), 1);
assertEquals(actualResult.getRow("EXTERN").getCells()[0], 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getTotalValue());
assertThat(1).isEqualTo(actualResult.getRow("EXTERN").getCells()[0]);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -243,8 +242,8 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
@ -254,7 +253,7 @@ class CategoryReportBuilderImplTest {
List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<String> result =
cut.createCategoryReportBuilder().listTaskIdsForSelectedItems(selectedItems);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -315,8 +314,8 @@ class CategoryReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
@ -326,6 +325,6 @@ class CategoryReportBuilderImplTest {
cut.createCategoryReportBuilder()
.workbasketIdIn(Arrays.asList("DieGibtsSicherNed"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_1);
assertNotNull(result);
assertThat(result).isNotNull();
}
}

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

@ -1,7 +1,6 @@
package pro.taskana.monitor.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
@ -113,10 +112,10 @@ class ClassificationReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(
actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -179,11 +178,12 @@ class ClassificationReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(
actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue(), 1);
assertEquals(actualResult.getRow("CLI:000000000000000000000000000000000001").getCells()[0], 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("CLI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(1)
.isEqualTo(actualResult.getRow("CLI:000000000000000000000000000000000001").getCells()[0]);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -243,11 +243,11 @@ class ClassificationReportBuilderImplTest {
FoldableRow<DetailedMonitorQueryItem> line =
actualResult.getRow("CLI:000000000000000000000000000000000001");
assertNotNull(actualResult);
assertEquals(line.getTotalValue(), 1);
assertEquals(
line.getFoldableRow("CLI:000000000000000000000000000000000006").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(line.getTotalValue());
assertThat(line.getFoldableRow("CLI:000000000000000000000000000000000006").getTotalValue())
.isEqualTo(1);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -311,14 +311,15 @@ class ClassificationReportBuilderImplTest {
FoldableRow<DetailedMonitorQueryItem> line =
actualResult.getRow("CLI:000000000000000000000000000000000001");
assertNotNull(actualResult);
assertEquals(line.getTotalValue(), 1);
assertEquals(
line.getFoldableRow("CLI:000000000000000000000000000000000006").getTotalValue(), 1);
assertEquals(line.getCells()[0], 1);
assertEquals(line.getFoldableRow("CLI:000000000000000000000000000000000006").getCells()[0], 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getCells()[0], 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(line.getTotalValue());
assertThat(line.getFoldableRow("CLI:000000000000000000000000000000000006").getTotalValue())
.isEqualTo(1);
assertThat(1).isEqualTo(line.getCells()[0]);
assertThat(1)
.isEqualTo(line.getFoldableRow("CLI:000000000000000000000000000000000006").getCells()[0]);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
assertThat(1).isEqualTo(actualResult.getSumRow().getCells()[0]);
}
@Test
@ -384,8 +385,8 @@ class ClassificationReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
@ -398,7 +399,7 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(Arrays.asList("DieGibtsEhNed"))
.listTaskIdsForSelectedItems(selectedItems);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -459,8 +460,8 @@ class ClassificationReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
@ -470,6 +471,6 @@ class ClassificationReportBuilderImplTest {
cut.createClassificationReportBuilder()
.workbasketIdIn(Collections.singletonList("DieGibtsGarantiertNed"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_10);
assertNotNull(result);
assertThat(result).isNotNull();
}
}

21
lib/taskana-core/src/test/java/pro/taskana/monitor/internal/CustomFieldValueReportBuilderImplTest.java
View File

@ -1,7 +1,6 @@
package pro.taskana.monitor.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@ -110,9 +109,9 @@ class CustomFieldValueReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfigurationMock);
assertNotNull(actualResult);
assertEquals(actualResult.getRow("Geschaeftsstelle A").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("Geschaeftsstelle A").getTotalValue());
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -174,10 +173,10 @@ class CustomFieldValueReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfigurationMock);
assertNotNull(actualResult);
assertEquals(actualResult.getRow("Geschaeftsstelle A").getTotalValue(), 1);
assertEquals(actualResult.getRow("Geschaeftsstelle A").getCells()[0], 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(1).isEqualTo(actualResult.getRow("Geschaeftsstelle A").getTotalValue());
assertThat(1).isEqualTo(actualResult.getRow("Geschaeftsstelle A").getCells()[0]);
assertThat(1).isEqualTo(actualResult.getSumRow().getTotalValue());
}
@Test
@ -238,7 +237,7 @@ class CustomFieldValueReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfigurationMock);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
}

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

@ -1,7 +1,6 @@
package pro.taskana.monitor.internal;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.Arrays;
@ -40,10 +39,10 @@ class ReportTest {
@Test
void testEmptyReport() {
// then
assertEquals(0, report.getRows().size());
assertThat(report.getRows()).isEmpty();
Row<MonitorQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {0, 0, 0, 0}, sumRow.getCells());
assertEquals(0, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {0, 0, 0, 0});
assertThat(sumRow.getTotalValue()).isEqualTo(0);
}
@Test
@ -52,10 +51,10 @@ class ReportTest {
report.addItem(item);
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow("key");
assertArrayEquals(new int[] {item.getValue(), 0, 0, 0}, row.getCells());
assertEquals(item.getValue(), row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {item.getValue(), 0, 0, 0});
assertThat(row.getTotalValue()).isEqualTo(item.getValue());
}
@Test
@ -65,10 +64,10 @@ class ReportTest {
report.addItem(item);
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow("key");
assertArrayEquals(new int[] {2 * item.getValue(), 0, 0, 0}, row.getCells());
assertEquals(2 * item.getValue(), row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {2 * item.getValue(), 0, 0, 0});
assertThat(row.getTotalValue()).isEqualTo(2 * item.getValue());
}
@Test
@ -83,10 +82,10 @@ class ReportTest {
report.addItems(Arrays.asList(item, item));
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow("key");
assertArrayEquals(new int[] {2 * item.getValue(), 0, 0, 0}, row.getCells());
assertEquals(2 * item.getValue(), row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {2 * item.getValue(), 0, 0, 0});
assertThat(row.getTotalValue()).isEqualTo(2 * item.getValue());
}
@Test
@ -102,10 +101,10 @@ class ReportTest {
report.addItems(Arrays.asList(item, item), preprocessor);
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow("key");
assertArrayEquals(new int[] {2 * overrideValue, 0, 0, 0}, row.getCells());
assertEquals(2 * overrideValue, row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {2 * overrideValue, 0, 0, 0});
assertThat(row.getTotalValue()).isEqualTo(2 * overrideValue);
}
@Test
@ -119,9 +118,9 @@ class ReportTest {
report.addItem(item);
// then
assertEquals(1, report.getRows().size());
assertArrayEquals(new int[0], report.getRow("key").getCells());
assertEquals(item.getValue(), report.getRow("key").getTotalValue());
assertThat(report.getRows()).hasSize(1);
assertThat(report.getRow("key").getCells()).isEqualTo(new int[0]);
assertThat(report.getRow("key").getTotalValue()).isEqualTo(item.getValue());
}
@Test
@ -132,10 +131,10 @@ class ReportTest {
report.addItem(item);
// then
assertEquals(0, report.getRows().size());
assertThat(report.getRows()).isEmpty();
Row<MonitorQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {0, 0, 0, 0}, sumRow.getCells());
assertEquals(0, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {0, 0, 0, 0});
assertThat(sumRow.getTotalValue()).isEqualTo(0);
}
@Test
@ -151,15 +150,15 @@ class ReportTest {
report.addItem(item);
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow("key");
assertArrayEquals(new int[] {0, 0, item.getValue(), 0, item.getValue()}, row.getCells());
assertEquals(2 * item.getValue(), row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {0, 0, item.getValue(), 0, item.getValue()});
assertThat(row.getTotalValue()).isEqualTo(2 * item.getValue());
Row<MonitorQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {0, 0, item.getValue(), 0, item.getValue()}, sumRow.getCells());
assertEquals(2 * item.getValue(), sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {0, 0, item.getValue(), 0, item.getValue()});
assertThat(sumRow.getTotalValue()).isEqualTo(2 * item.getValue());
}
@Test
@ -177,15 +176,15 @@ class ReportTest {
report.addItem(item, preprocessor);
// then
assertEquals(1, report.getRows().size());
assertThat(report.getRows()).hasSize(1);
Row<MonitorQueryItem> row = report.getRow(item.getKey());
assertArrayEquals(new int[] {0, overrideValue, 0, 0}, row.getCells());
assertEquals(overrideValue, row.getTotalValue());
assertThat(row.getCells()).isEqualTo(new int[] {0, overrideValue, 0, 0});
assertThat(row.getTotalValue()).isEqualTo(overrideValue);
Row<MonitorQueryItem> sumRow = report.getSumRow();
assertArrayEquals(new int[] {0, overrideValue, 0, 0}, sumRow.getCells());
assertEquals(overrideValue, sumRow.getTotalValue());
assertThat(sumRow.getCells()).isEqualTo(new int[] {0, overrideValue, 0, 0});
assertThat(sumRow.getTotalValue()).isEqualTo(overrideValue);
}
private static class MonitorQueryItemTimeIntervalColumnHeaderReport

19
lib/taskana-core/src/test/java/pro/taskana/sampledata/SampleDataGeneratorTest.java
View File

@ -1,7 +1,9 @@
package pro.taskana.sampledata;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import pro.taskana.common.internal.configuration.DbSchemaCreator;
@ -15,20 +17,23 @@ class SampleDataGeneratorTest {
@Test
void getScriptsValidSql() {
PooledDataSource pooledDataSource = new PooledDataSource("org.h2.Driver", JDBC_URL, "sa", "sa");
Assertions.assertDoesNotThrow(() -> new DbSchemaCreator(pooledDataSource, "TASKANA").run());
Assertions.assertDoesNotThrow(
() -> new SampleDataGenerator(pooledDataSource, "TASKANA").generateSampleData());
assertThatCode(() -> new DbSchemaCreator(pooledDataSource, "TASKANA").run())
.doesNotThrowAnyException();
assertThatCode(() -> new SampleDataGenerator(pooledDataSource, "TASKANA").generateSampleData())
.doesNotThrowAnyException();
pooledDataSource.forceCloseAll();
}
@Test
void tableExists() {
PooledDataSource pooledDataSource = new PooledDataSource("org.h2.Driver", JDBC_URL, "sa", "sa");
Assertions.assertDoesNotThrow(() -> new DbSchemaCreator(pooledDataSource, "TASKANA").run());
assertThatCode(() -> new DbSchemaCreator(pooledDataSource, "TASKANA").run())
.doesNotThrowAnyException();
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(pooledDataSource, "TASKANA");
Assertions.assertTrue(sampleDataGenerator.tableExists("TASK"));
Assertions.assertFalse(sampleDataGenerator.tableExists("TASKRANDOM"));
assertThat(sampleDataGenerator.tableExists("TASK")).isTrue();
assertThat(sampleDataGenerator.tableExists("TASKRANDOM")).isFalse();
pooledDataSource.forceCloseAll();
}
}

48
lib/taskana-core/src/test/java/pro/taskana/security/JaasExtension.java
View File

@ -2,6 +2,7 @@ package pro.taskana.security;
import java.lang.reflect.Method;
import java.security.Principal;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.List;
@ -17,22 +18,49 @@ import pro.taskana.common.internal.security.UserPrincipal;
/** Runner for integration tests that enables JAAS subject. */
public class JaasExtension implements InvocationInterceptor {
@Override
public void interceptBeforeEachMethod(
Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext)
throws Throwable {
extractAccessId(invocation, invocationContext.getExecutable());
}
@Override
public void interceptTestMethod(
Invocation<Void> invocation,
ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext)
throws Throwable {
extractAccessId(invocation, invocationContext.getExecutable());
}
@Override
public <T> T interceptTestFactoryMethod(
Invocation<T> invocation,
ReflectiveInvocationContext<Method> invocationContext,
ExtensionContext extensionContext)
throws Throwable {
return extractAccessId(invocation, invocationContext.getExecutable());
}
@Override
public void interceptDynamicTest(Invocation<Void> invocation, ExtensionContext extensionContext)
throws Throwable {
extractAccessId(invocation, extensionContext.getParent().get().getRequiredTestMethod());
}
private <T> T extractAccessId(Invocation<T> invocation, Method method)
throws PrivilegedActionException {
// check for access
Subject subject = new Subject();
List<Principal> principalList = new ArrayList<>();
WithAccessId withAccessId = invocationContext.getExecutable().getAnnotation(WithAccessId.class);
WithAccessId withAccessId = method.getAnnotation(WithAccessId.class);
if (withAccessId != null) {
if (withAccessId.userName() != null) {
principalList.add(new UserPrincipal(withAccessId.userName()));
}
withAccessId.userName();
principalList.add(new UserPrincipal(withAccessId.userName()));
for (String groupName : withAccessId.groupNames()) {
if (groupName != null) {
principalList.add(new GroupPrincipal(groupName));
@ -40,21 +68,19 @@ public class JaasExtension implements InvocationInterceptor {
}
}
subject.getPrincipals().addAll(principalList);
Subject.doAs(subject, getObjectPrivilegedExceptionAction(invocation, invocationContext));
return Subject.doAs(subject, getObjectPrivilegedExceptionAction(invocation, method));
}
private PrivilegedExceptionAction<Object> getObjectPrivilegedExceptionAction(
Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext) {
private <T> PrivilegedExceptionAction<T> getObjectPrivilegedExceptionAction(
Invocation<T> invocation, Method invocationContext) {
return () -> {
try {
invocation.proceed();
return invocation.proceed();
} catch (Exception | Error e) {
throw e;
} catch (Throwable e) {
throw new JUnitException(
"Execution of test failed: " + invocationContext.getExecutable().getName(), e);
throw new JUnitException("Execution of test failed: " + invocationContext.getName(), e);
}
return null;
};
}
}

8
lib/taskana-core/src/test/java/pro/taskana/task/internal/ObjectReferenceQueryImplTest.java
View File

@ -1,6 +1,6 @@
package pro.taskana.task.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ -47,7 +47,7 @@ class ObjectReferenceQueryImplTest {
.systemInstanceIn("1", "2")
.systemIn("superId")
.list();
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -62,7 +62,7 @@ class ObjectReferenceQueryImplTest {
.systemInstanceIn("1", "2")
.systemIn("superId")
.list(1, 1);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -77,6 +77,6 @@ class ObjectReferenceQueryImplTest {
.systemInstanceIn("1", "2")
.systemIn("superId")
.single();
assertNotNull(result);
assertThat(result).isNotNull();
}
}

52
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskAttachmentTest.java
View File

@ -1,8 +1,6 @@
package pro.taskana.task.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import java.util.HashMap;
@ -35,7 +33,7 @@ class TaskAttachmentTest {
cut.addAttachment(attachment2);
cut.addAttachment(attachment3);
assertThat(cut.getAttachments().size(), equalTo(3));
assertThat(cut.getAttachments()).hasSize(3);
}
@Test
@ -45,7 +43,7 @@ class TaskAttachmentTest {
cut.addAttachment(attachment1);
cut.addAttachment(null);
assertThat(cut.getAttachments().size(), equalTo(1));
assertThat(cut.getAttachments()).hasSize(1);
}
@Test
@ -57,14 +55,14 @@ class TaskAttachmentTest {
cut.addAttachment(attachment1);
cut.addAttachment(attachment2);
assertThat(cut.getAttachments().size(), equalTo(1));
assertThat(cut.getAttachments()).hasSize(1);
// Check with not same vlaues (same ID)
String newChannel = "I will overwrite the other!";
attachment1.setChannel(newChannel);
cut.addAttachment(attachment1);
assertThat(cut.getAttachments().size(), equalTo(1));
assertThat(cut.getAttachments().get(0).getChannel(), equalTo(newChannel));
assertThat(cut.getAttachments()).hasSize(1);
assertThat(cut.getAttachments().get(0).getChannel()).isEqualTo(newChannel);
}
@Test
@ -77,8 +75,8 @@ class TaskAttachmentTest {
Attachment actual = cut.removeAttachment(attachment2.getId());
assertThat(cut.getAttachments().size(), equalTo(1));
assertThat(actual, equalTo(attachment2));
assertThat(cut.getAttachments()).hasSize(1);
assertThat(actual).isEqualTo(attachment2);
}
@Test
@ -88,12 +86,12 @@ class TaskAttachmentTest {
cut.getAttachments().add(attachment1);
cut.getAttachments().add(attachment1);
cut.getAttachments().add(attachment1);
assertThat(cut.getAttachments().size(), equalTo(3));
assertThat(cut.getAttachments()).hasSize(3);
Attachment actual = cut.removeAttachment(attachment1.getId());
assertThat(cut.getAttachments().size(), equalTo(2));
assertThat(actual, equalTo(attachment1));
assertThat(cut.getAttachments()).hasSize(2);
assertThat(actual).isEqualTo(attachment1);
}
@Test
@ -117,25 +115,23 @@ class TaskAttachmentTest {
List<AttachmentSummary> summaries = cut.asSummary().getAttachmentSummaries();
AttachmentSummary attachmentSummary = summaries.get(0);
assertThat(attachmentSummary, equalTo(attachment1.asSummary()));
assertThat(attachmentSummary.getId(), equalTo(attachment1.getId()));
assertThat(attachmentSummary.getTaskId(), equalTo(attachment1.getTaskId()));
assertThat(attachmentSummary.getChannel(), equalTo(attachment1.getChannel()));
assertThat(
attachmentSummary.getClassificationSummary(),
equalTo(attachment1.getClassificationSummary()));
assertThat(attachmentSummary.getObjectReference(), equalTo(attachment1.getObjectReference()));
assertThat(attachmentSummary.getCreated(), equalTo(attachment1.getCreated()));
assertThat(attachmentSummary.getReceived(), equalTo(attachment1.getReceived()));
assertThat(attachmentSummary.getModified(), equalTo(attachment1.getModified()));
assertThat(attachmentSummary).isEqualTo(attachment1.asSummary());
assertThat(attachmentSummary.getId()).isEqualTo(attachment1.getId());
assertThat(attachmentSummary.getTaskId()).isEqualTo(attachment1.getTaskId());
assertThat(attachmentSummary.getChannel()).isEqualTo(attachment1.getChannel());
assertThat(attachmentSummary.getClassificationSummary())
.isEqualTo(attachment1.getClassificationSummary());
assertThat(attachmentSummary.getObjectReference()).isEqualTo(attachment1.getObjectReference());
assertThat(attachmentSummary.getCreated()).isEqualTo(attachment1.getCreated());
assertThat(attachmentSummary.getReceived()).isEqualTo(attachment1.getReceived());
assertThat(attachmentSummary.getModified()).isEqualTo(attachment1.getModified());
// Must be different
assertNotEquals(attachmentSummary.hashCode(), attachment1.hashCode());
assertThat(attachment1.hashCode()).isNotEqualTo(attachmentSummary.hashCode());
cut.removeAttachment("ID1");
assertThat(summaries.size(), equalTo(1));
assertThat(summaries).hasSize(1);
summaries = cut.asSummary().getAttachmentSummaries();
assertThat(summaries.size(), equalTo(0));
assertThat(summaries).isEmpty();
}
}

8
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskQueryImplTest.java
View File

@ -1,6 +1,6 @@
package pro.taskana.task.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ -62,7 +62,7 @@ class TaskQueryImplTest {
.priorityIn(1, 2)
.stateIn(TaskState.CLAIMED, TaskState.COMPLETED)
.list();
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -78,7 +78,7 @@ class TaskQueryImplTest {
.priorityIn(1, 2)
.stateIn(TaskState.CLAIMED, TaskState.COMPLETED)
.list(1, 1);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -95,6 +95,6 @@ class TaskQueryImplTest {
.priorityIn(1, 2)
.stateIn(TaskState.CLAIMED, TaskState.COMPLETED)
.single();
assertNotNull(result);
assertThat(result).isNotNull();
}
}

94
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplIntAutocommitTest.java
View File

@ -1,17 +1,14 @@
package pro.taskana.task.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;
import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -76,12 +73,12 @@ class TaskServiceImplIntAutocommitTest {
private WorkbasketService workbasketService;
private SampleDataGenerator sampleDataGenerator;
private static SampleDataGenerator sampleDataGenerator;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private static TaskanaEngineConfiguration taskanaEngineConfiguration;
@BeforeAll
void beforeAll() throws SQLException {
static void beforeAll() throws SQLException {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
@ -130,7 +127,7 @@ class TaskServiceImplIntAutocommitTest {
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Task resultTask = taskServiceImpl2.getTask(task.getId());
assertNotNull(resultTask);
assertThat(resultTask).isNotNull();
}
@Test
@ -163,8 +160,11 @@ class TaskServiceImplIntAutocommitTest {
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Assertions.assertThrows(
TaskNotFoundException.class, () -> taskServiceImpl2.getTask(wb.getId()));
ThrowingCallable call =
() -> {
taskServiceImpl2.getTask(wb.getId());
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@Test
@ -206,7 +206,7 @@ class TaskServiceImplIntAutocommitTest {
.primaryObjectReferenceValueIn("val1", "val2", "val3")
.list();
assertEquals(0, results.size());
assertThat(results).isEmpty();
}
@Test
@ -254,20 +254,23 @@ class TaskServiceImplIntAutocommitTest {
Thread.sleep(sleepTime); // Sleep for modification-timestamp
Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId());
assertThat(resultTask.isRead(), equalTo(false));
assertThat(resultTask.isTransferred(), equalTo(true));
assertThat(resultTask.getWorkbasketSummary().getId(), equalTo(destinationWB.getId()));
assertThat(resultTask.getModified(), not(equalTo(null)));
assertThat(resultTask.getModified(), not(equalTo(task.getModified())));
assertThat(resultTask.getCreated(), not(equalTo(null)));
assertThat(resultTask.getCreated(), equalTo(task.getCreated()));
assertThat(resultTask.isRead()).isFalse();
assertThat(resultTask.isTransferred()).isTrue();
assertThat(resultTask.getWorkbasketSummary().getId()).isEqualTo(destinationWB.getId());
assertThat(resultTask.getModified()).isNotNull();
assertThat(resultTask.getModified()).isNotEqualTo(task.getModified());
assertThat(resultTask.getCreated()).isNotNull();
assertThat(resultTask.getCreated()).isEqualTo(task.getCreated());
}
@Test
void shouldNotTransferAnyTask() {
Assertions.assertThrows(
TaskNotFoundException.class, () -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"));
ThrowingCallable call =
() -> {
taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(
@ -337,19 +340,19 @@ class TaskServiceImplIntAutocommitTest {
task.setPrimaryObjRef(JunitHelper.createDefaultObjRef());
TaskImpl taskCreated = (TaskImpl) taskServiceImpl.createTask(task);
// Check failing with missing APPEND
NotAuthorizedException e =
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskServiceImpl.transfer(taskCreated.getId(), wbNoAppendCreated.getId()),
"Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB.");
ThrowingCallable call =
() -> {
taskServiceImpl.transfer(taskCreated.getId(), wbNoAppendCreated.getId());
};
assertThatThrownBy(call)
.describedAs(
"Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB.")
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("APPEND");
Assertions.assertTrue(
e.getMessage().contains("APPEND"),
"Transfer Task should be FAILD, because there are no APPEND-Rights on destination WB.");
assertThat(taskCreated.isTransferred(), equalTo(false));
assertThat(taskCreated.getWorkbasketKey(), not(equalTo(wbNoAppendCreated.getKey())));
assertThat(taskCreated.getWorkbasketKey(), equalTo(wbCreated.getKey()));
assertThat(taskCreated.isTransferred()).isFalse();
assertThat(taskCreated.getWorkbasketKey()).isNotEqualTo(wbNoAppendCreated.getKey());
assertThat(taskCreated.getWorkbasketKey()).isEqualTo(wbCreated.getKey());
// Check failing with missing TRANSFER
taskCreated.setId("");
@ -359,17 +362,18 @@ class TaskServiceImplIntAutocommitTest {
TaskImpl taskCreated2 = (TaskImpl) taskServiceImpl.createTask(taskCreated);
e =
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskServiceImpl.transfer(taskCreated2.getId(), wbCreated.getId()),
"Transfer Task should be FAILED, because there are no TRANSFER-Rights on current WB.");
Assertions.assertTrue(
e.getMessage().contains("TRANSFER"),
"Transfer Task should be FAILED, because there are no APPEND-Rights on current WB.");
call =
() -> {
taskServiceImpl.transfer(taskCreated2.getId(), wbCreated.getId());
};
assertThatThrownBy(call)
.describedAs(
"Transfer Task should be FAILED, because there are no TRANSFER-Rights on current WB.")
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("TRANSFER");
assertThat(taskCreated2.isTransferred(), equalTo(false));
assertThat(taskCreated2.getWorkbasketKey(), not(equalTo(wbNoAppendCreated.getKey())));
assertThat(taskCreated2.isTransferred()).isFalse();
assertThat(taskCreated2.getWorkbasketKey()).isNotEqualTo(wbNoAppendCreated.getKey());
}
@Test
@ -405,7 +409,7 @@ class TaskServiceImplIntAutocommitTest {
// skanaEngineImpl.getSqlSession().commit(); // needed so that the change is visible in the
// other session
assertNotNull(task2);
assertThat(task2).isNotNull();
}
private void createWorkbasketWithSecurity(

126
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplIntExplicitTest.java
View File

@ -1,11 +1,7 @@
package pro.taskana.task.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.sql.Connection;
@ -13,8 +9,8 @@ import java.sql.SQLException;
import java.util.List;
import java.util.UUID;
import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -68,7 +64,7 @@ import pro.taskana.workbasket.internal.models.WorkbasketSummaryImpl;
@ExtendWith(JaasExtension.class)
class TaskServiceImplIntExplicitTest {
private DataSource dataSource;
private static DataSource dataSource;
private TaskServiceImpl taskServiceImpl;
@ -80,12 +76,12 @@ class TaskServiceImplIntExplicitTest {
private WorkbasketService workbasketService;
private SampleDataGenerator sampleDataGenerator;
private static SampleDataGenerator sampleDataGenerator;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private static TaskanaEngineConfiguration taskanaEngineConfiguration;
@BeforeAll
void beforeAll() throws SQLException {
static void beforeAll() throws SQLException {
String userHomeDirectory = System.getProperty("user.home");
String propertiesFileName = userHomeDirectory + "/taskanaUnitTest.properties";
@ -96,6 +92,8 @@ class TaskServiceImplIntExplicitTest {
taskanaEngineConfiguration =
new TaskanaEngineConfiguration(
dataSource, false, TaskanaEngineTestConfiguration.getSchemaName());
sampleDataGenerator =
new SampleDataGenerator(dataSource, TaskanaEngineTestConfiguration.getSchemaName());
}
@BeforeEach
@ -159,8 +157,11 @@ class TaskServiceImplIntExplicitTest {
TaskanaEngineImpl te2 = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Assertions.assertThrows(
TaskNotFoundException.class, () -> taskServiceImpl2.getTask(workbasket.getId()));
ThrowingCallable call =
() -> {
taskServiceImpl2.getTask(workbasket.getId());
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
connection.commit();
}
}
@ -194,7 +195,7 @@ class TaskServiceImplIntExplicitTest {
TaskanaEngine te2 = taskanaEngineConfiguration.buildTaskanaEngine();
TaskServiceImpl taskServiceImpl2 = (TaskServiceImpl) te2.getTaskService();
Task resultTask = taskServiceImpl2.getTask(task2.getId());
assertNotNull(resultTask);
assertThat(resultTask).isNotNull();
connection.commit();
}
}
@ -212,8 +213,11 @@ class TaskServiceImplIntExplicitTest {
Task test = this.generateDummyTask();
((WorkbasketSummaryImpl) (test.getWorkbasketSummary())).setId("2");
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> taskServiceImpl.createTask(test));
ThrowingCallable call =
() -> {
taskServiceImpl.createTask(test);
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
}
@ -246,8 +250,11 @@ class TaskServiceImplIntExplicitTest {
((TaskImpl) task).setWorkbasketSummary(wb.asSummary());
task.setClassificationKey(classification.getKey());
Assertions.assertThrows(
ClassificationNotFoundException.class, () -> taskServiceImpl.createTask(task));
ThrowingCallable call =
() -> {
taskServiceImpl.createTask(task);
};
assertThatThrownBy(call).isInstanceOf(ClassificationNotFoundException.class);
}
}
@ -303,7 +310,7 @@ class TaskServiceImplIntExplicitTest {
.primaryObjectReferenceValueIn("val1", "val2", "val3")
.list();
assertEquals(0, results.size());
assertThat(results).isEmpty();
connection.commit();
}
}
@ -335,12 +342,13 @@ class TaskServiceImplIntExplicitTest {
workbasketService.createWorkbasketAccessItem(
createWorkbasketWithSecurity(wb, wb.getOwner(), true, true, true, true));
connection.commit();
Assertions.assertThrows(
WorkbasketAccessItemAlreadyExistException.class,
() ->
workbasketService.createWorkbasketAccessItem(
createWorkbasketWithSecurity(
sourceWB, sourceWB.getOwner(), false, false, false, false)));
ThrowingCallable call =
() -> {
workbasketService.createWorkbasketAccessItem(
createWorkbasketWithSecurity(
sourceWB, sourceWB.getOwner(), false, false, false, false));
};
assertThatThrownBy(call).isInstanceOf(WorkbasketAccessItemAlreadyExistException.class);
connection.rollback();
// Destination Workbasket
@ -378,13 +386,13 @@ class TaskServiceImplIntExplicitTest {
Task resultTask = taskServiceImpl.transfer(task.getId(), destinationWB.getId());
connection.commit();
assertThat(resultTask.isRead(), equalTo(false));
assertThat(resultTask.isTransferred(), equalTo(true));
assertThat(resultTask.getWorkbasketKey(), equalTo(destinationWB.getKey()));
assertThat(resultTask.getModified(), not(equalTo(null)));
assertThat(resultTask.getModified(), not(equalTo(task.getModified())));
assertThat(resultTask.getCreated(), not(equalTo(null)));
assertThat(resultTask.getCreated(), equalTo(task.getCreated()));
assertThat(resultTask.isRead()).isFalse();
assertThat(resultTask.isTransferred()).isTrue();
assertThat(resultTask.getWorkbasketKey()).isEqualTo(destinationWB.getKey());
assertThat(resultTask.getModified()).isNotNull();
assertThat(resultTask.getModified()).isNotEqualTo(task.getModified());
assertThat(resultTask.getCreated()).isNotNull();
assertThat(resultTask.getCreated()).isEqualTo(task.getCreated());
}
}
@ -393,9 +401,11 @@ class TaskServiceImplIntExplicitTest {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
Assertions.assertThrows(
TaskNotFoundException.class,
() -> taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1"));
ThrowingCallable call =
() -> {
taskServiceImpl.transfer(UUID.randomUUID() + "_X", "1");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
}
@ -470,21 +480,20 @@ class TaskServiceImplIntExplicitTest {
TaskImpl taskCreated = (TaskImpl) taskServiceImpl.createTask(task);
// Check failing with missing APPEND
NotAuthorizedException e =
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskServiceImpl.transfer(taskCreated.getId(), wbNoAppendCreated.getId()),
ThrowingCallable call =
() -> {
taskServiceImpl.transfer(taskCreated.getId(), wbNoAppendCreated.getId());
};
assertThatThrownBy(call)
.describedAs(
"Transfer Task should be FAILED, "
+ "because there are no APPEND-Rights on destination WB.");
+ "because there are no APPEND-Rights on destination WB.")
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("APPEND");
assertTrue(
e.getMessage().contains("APPEND"),
"Transfer Task should be FAILED, "
+ "because there are no APPEND-Rights on destination WB.");
assertThat(taskCreated.isTransferred(), equalTo(false));
assertThat(taskCreated.getWorkbasketKey(), not(equalTo(wbNoAppendCreated.getKey())));
assertThat(taskCreated.getWorkbasketKey(), equalTo(wbCreated.getKey()));
assertThat(taskCreated.isTransferred()).isFalse();
assertThat(taskCreated.getWorkbasketKey()).isNotEqualTo(wbNoAppendCreated.getKey());
assertThat(taskCreated.getWorkbasketKey()).isEqualTo(wbCreated.getKey());
// Check failing with missing TRANSFER
taskCreated.setId("");
@ -492,17 +501,18 @@ class TaskServiceImplIntExplicitTest {
taskCreated.getWorkbasketSummaryImpl().setId(wbNoTransfer.getId());
taskCreated.setExternalId(IdGenerator.generateWithPrefix("TST"));
TaskImpl taskCreated2 = (TaskImpl) taskServiceImpl.createTask(taskCreated);
e =
Assertions.assertThrows(
NotAuthorizedException.class,
() -> taskServiceImpl.transfer(taskCreated2.getId(), wbCreated.getId()),
"Transfer Task should be FAILED, because there are no TRANSFER-Rights on current WB.");
call =
() -> {
taskServiceImpl.transfer(taskCreated2.getId(), wbCreated.getId());
};
assertThatThrownBy(call)
.describedAs(
"Transfer Task should be FAILED, because there are no TRANSFER-Rights on current WB.")
.isInstanceOf(NotAuthorizedException.class)
.hasMessageContaining("TRANSFER");
assertTrue(
e.getMessage().contains("TRANSFER"),
"Transfer Task should be FAILED, because there are no APPEND-Rights on current WB.");
assertThat(taskCreated2.isTransferred(), equalTo(false));
assertThat(taskCreated2.getWorkbasketKey(), not(equalTo(wbNoAppendCreated.getKey())));
assertThat(taskCreated2.isTransferred()).isFalse();
assertThat(taskCreated2.getWorkbasketKey()).isNotEqualTo(wbNoAppendCreated.getKey());
}
@AfterEach

19
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskServiceImplTest.java
View File

@ -1,7 +1,6 @@
package pro.taskana.task.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
@ -36,24 +35,24 @@ class TaskServiceImplTest {
TaskSummary summaryBefore = taskBefore.asSummary();
TaskSummary summaryAfter = taskAfter.asSummary();
assertNotEquals(summaryBefore, summaryAfter);
assertNotEquals(summaryBefore.hashCode(), summaryAfter.hashCode());
assertThat(summaryAfter).isNotEqualTo(summaryBefore);
assertThat(summaryAfter.hashCode()).isNotEqualTo(summaryBefore.hashCode());
taskAfter.setCreated(taskBefore.getCreated());
taskAfter.setModified(taskBefore.getModified());
summaryAfter = taskAfter.asSummary();
assertEquals(summaryBefore, summaryAfter);
assertEquals(summaryBefore.hashCode(), summaryAfter.hashCode());
assertThat(summaryAfter).isEqualTo(summaryBefore);
assertThat(summaryAfter.hashCode()).isEqualTo(summaryBefore.hashCode());
taskBefore.setModified(null);
summaryBefore = taskBefore.asSummary();
assertNotEquals(summaryBefore, summaryAfter);
assertNotEquals(summaryBefore.hashCode(), summaryAfter.hashCode());
assertThat(summaryAfter).isNotEqualTo(summaryBefore);
assertThat(summaryAfter.hashCode()).isNotEqualTo(summaryBefore.hashCode());
taskAfter.setModified(null);
summaryAfter = taskAfter.asSummary();
assertEquals(summaryBefore, summaryAfter);
assertEquals(summaryBefore.hashCode(), summaryAfter.hashCode());
assertThat(summaryAfter).isEqualTo(summaryBefore);
assertThat(summaryAfter.hashCode()).isEqualTo(summaryBefore.hashCode());
}
static Classification createDummyClassification() {

28
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskStatusReportBuilderImplTest.java
View File

@ -1,8 +1,6 @@
package pro.taskana.task.internal;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@ -75,12 +73,12 @@ class TaskStatusReportBuilderImplTest {
inOrder.verifyNoMoreInteractions();
verifyNoMoreInteractions(taskanaEngineMock, internalTaskanaEngineMock, monitorMapperMock);
assertNotNull(report);
assertEquals(1, report.rowSize());
assertArrayEquals(new int[] {50, 0, 30, 0, 0}, report.getRow("DOMAIN_X").getCells());
assertArrayEquals(new int[] {50, 0, 30, 0, 0}, report.getSumRow().getCells());
assertEquals(80, report.getRow("DOMAIN_X").getTotalValue());
assertEquals(80, report.getSumRow().getTotalValue());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
assertThat(report.getRow("DOMAIN_X").getCells()).isEqualTo(new int[] {50, 0, 30, 0, 0});
assertThat(report.getSumRow().getCells()).isEqualTo(new int[] {50, 0, 30, 0, 0});
assertThat(report.getRow("DOMAIN_X").getTotalValue()).isEqualTo(80);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(80);
}
@Test
@ -113,11 +111,11 @@ class TaskStatusReportBuilderImplTest {
inOrder.verifyNoMoreInteractions();
verifyNoMoreInteractions(taskanaEngineMock, monitorMapperMock, internalTaskanaEngineMock);
assertNotNull(report);
assertEquals(1, report.rowSize());
assertArrayEquals(new int[0], report.getRow("DOMAIN_X").getCells());
assertArrayEquals(new int[0], report.getSumRow().getCells());
assertEquals(80, report.getRow("DOMAIN_X").getTotalValue());
assertEquals(80, report.getSumRow().getTotalValue());
assertThat(report).isNotNull();
assertThat(report.rowSize()).isEqualTo(1);
assertThat(report.getRow("DOMAIN_X").getCells()).isEqualTo(new int[0]);
assertThat(report.getSumRow().getCells()).isEqualTo(new int[0]);
assertThat(report.getRow("DOMAIN_X").getTotalValue()).isEqualTo(80);
assertThat(report.getSumRow().getTotalValue()).isEqualTo(80);
}
}

11
lib/taskana-core/src/test/java/pro/taskana/task/internal/TaskTransferrerTest.java
View File

@ -1,7 +1,6 @@
package pro.taskana.task.internal;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
@ -109,9 +108,9 @@ class TaskTransferrerTest {
sqlSessionMock,
classificationQueryImplMock);
assertThat(actualTask.isRead(), equalTo(false));
assertThat(actualTask.getState(), equalTo(TaskState.READY));
assertThat(actualTask.isTransferred(), equalTo(true));
assertThat(actualTask.getWorkbasketKey(), equalTo(destinationWorkbasket.getKey()));
assertThat(actualTask.isRead()).isFalse();
assertThat(actualTask.getState()).isEqualTo(TaskState.READY);
assertThat(actualTask.isTransferred()).isTrue();
assertThat(actualTask.getWorkbasketKey()).isEqualTo(destinationWorkbasket.getKey());
}
}

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

@ -1,4 +1,4 @@
package pro.taskana.task.api.models;
package pro.taskana.task.internal.models;
import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.task.internal.CreateTaskModelHelper.createAttachment;
@ -12,11 +12,9 @@ import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import pro.taskana.task.internal.models.AttachmentImpl;
import pro.taskana.task.internal.models.AttachmentSummaryImpl;
import pro.taskana.task.internal.models.TaskCommentImpl;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.task.internal.models.TaskSummaryImpl;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.AttachmentSummary;
import pro.taskana.task.api.models.ObjectReference;
class TaskModelsCloneTest {

8
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketAccessItemQueryImplTest.java
View File

@ -1,6 +1,6 @@
package pro.taskana.workbasket.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ -37,7 +37,7 @@ class WorkbasketAccessItemQueryImplTest {
List<WorkbasketAccessItem> result =
workbasketAccessItemQueryImpl.accessIdIn("test", "asd").list();
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -47,7 +47,7 @@ class WorkbasketAccessItemQueryImplTest {
List<WorkbasketAccessItem> result =
workbasketAccessItemQueryImpl.accessIdIn("test", "asd").list(1, 1);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -56,6 +56,6 @@ class WorkbasketAccessItemQueryImplTest {
when(sqlSession.selectOne(any(), any())).thenReturn(new WorkbasketAccessItemImpl());
WorkbasketAccessItem result = workbasketAccessItemQueryImpl.accessIdIn("test", "asd").single();
assertNotNull(result);
assertThat(result).isNotNull();
}
}

8
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketQueryImplTest.java
View File

@ -1,6 +1,6 @@
package pro.taskana.workbasket.internal;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
@ -50,7 +50,7 @@ class WorkbasketQueryImplTest {
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%")
.list();
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -63,7 +63,7 @@ class WorkbasketQueryImplTest {
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%")
.list(1, 1);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -76,6 +76,6 @@ class WorkbasketQueryImplTest {
.nameIn("Gruppenpostkorb KSC 1", "Gruppenpostkorb KSC 2")
.keyLike("GPK_%")
.single();
assertNotNull(result);
assertThat(result).isNotNull();
}
}

51
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketReportBuilderImplTest.java
View File

@ -1,7 +1,7 @@
package pro.taskana.workbasket.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.times;
@ -15,7 +15,7 @@ import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -122,10 +122,10 @@ class WorkbasketReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(
actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(actualResult.getSumRow().getTotalValue()).isEqualTo(1);
}
@Test
@ -193,11 +193,12 @@ class WorkbasketReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(
actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue(), 1);
assertEquals(actualResult.getRow("WBI:000000000000000000000000000000000001").getCells()[0], 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(actualResult.getRow("WBI:000000000000000000000000000000000001").getCells()[0])
.isEqualTo(1);
assertThat(actualResult.getSumRow().getTotalValue()).isEqualTo(1);
}
@Test
@ -264,22 +265,22 @@ class WorkbasketReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
void testListTaskIdsForSelectedItemsIsEmptyResult() {
List<SelectedItem> selectedItems = new ArrayList<>();
Assertions.assertThrows(
InvalidArgumentException.class,
ThrowingCallable call =
() -> {
List<String> result =
cut.createWorkbasketReportBuilder()
.workbasketIdIn(Arrays.asList("DieGibtsGarantiertNed"))
.listTaskIdsForSelectedItems(selectedItems);
assertNotNull(result);
});
assertThat(result).isNotNull();
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
}
@Test
@ -340,8 +341,8 @@ class WorkbasketReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(expectedResult, actualResult);
assertThat(actualResult).isNotNull();
assertThat(actualResult).isEqualTo(expectedResult);
}
@Test
@ -351,7 +352,7 @@ class WorkbasketReportBuilderImplTest {
cut.createWorkbasketReportBuilder()
.workbasketIdIn(Arrays.asList("GibtsSicherNed"))
.listCustomAttributeValuesForCustomAttributeName(CustomField.CUSTOM_14);
assertNotNull(result);
assertThat(result).isNotNull();
}
@Test
@ -423,9 +424,9 @@ class WorkbasketReportBuilderImplTest {
monitorMapperMock,
taskanaEngineConfiguration);
assertNotNull(actualResult);
assertEquals(
actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue(), 1);
assertEquals(actualResult.getSumRow().getTotalValue(), 1);
assertThat(actualResult).isNotNull();
assertThat(actualResult.getRow("WBI:000000000000000000000000000000000001").getTotalValue())
.isEqualTo(1);
assertThat(actualResult.getSumRow().getTotalValue()).isEqualTo(1);
}
}

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

@ -1,15 +1,14 @@
package pro.taskana.workbasket.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.SQLException;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import javax.sql.DataSource;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@ -48,7 +47,6 @@ class WorkbasketServiceImplIntAutocommitTest {
private static final int SLEEP_TIME = 100;
private TaskanaEngine taskanaEngine;
private WorkbasketService workBasketService;
private Instant now;
@BeforeAll
static void resetDb() {
@ -68,13 +66,15 @@ class WorkbasketServiceImplIntAutocommitTest {
workBasketService = taskanaEngine.getWorkbasketService();
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
sampleDataGenerator.clearDb();
now = Instant.now();
}
@Test
void testGetWorkbasketFail() {
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> workBasketService.getWorkbasket("fail"));
ThrowingCallable call =
() -> {
workBasketService.getWorkbasket("fail");
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@WithAccessId(
@ -120,17 +120,14 @@ class WorkbasketServiceImplIntAutocommitTest {
List<WorkbasketSummary> distributionTargets =
workBasketService.getDistributionTargets(foundBasket.getId());
assertEquals(1, distributionTargets.size());
assertEquals(id3, distributionTargets.get(0).getId());
assertNotEquals(
workBasketService.getWorkbasket(id2).getCreated(),
workBasketService.getWorkbasket(id2).getModified());
assertEquals(
workBasketService.getWorkbasket(id1).getCreated(),
workBasketService.getWorkbasket(id1).getModified());
assertEquals(
workBasketService.getWorkbasket(id3).getCreated(),
workBasketService.getWorkbasket(id3).getModified());
assertThat(distributionTargets).hasSize(1);
assertThat(distributionTargets.get(0).getId()).isEqualTo(id3);
assertThat(workBasketService.getWorkbasket(id2).getCreated())
.isNotEqualTo(workBasketService.getWorkbasket(id2).getModified());
assertThat(workBasketService.getWorkbasket(id1).getCreated())
.isEqualTo(workBasketService.getWorkbasket(id1).getModified());
assertThat(workBasketService.getWorkbasket(id3).getCreated())
.isEqualTo(workBasketService.getWorkbasket(id3).getModified());
}
@WithAccessId(
@ -157,11 +154,11 @@ class WorkbasketServiceImplIntAutocommitTest {
accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(
1,
workBasketService
.getWorkbasketAccessItems("k100000000000000000000000000000000000000")
.size());
assertThat(1)
.isEqualTo(
workBasketService
.getWorkbasketAccessItems("k100000000000000000000000000000000000000")
.size());
}
@WithAccessId(
@ -186,19 +183,19 @@ class WorkbasketServiceImplIntAutocommitTest {
accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(
1,
workBasketService
.getWorkbasketAccessItems("k200000000000000000000000000000000000000")
.size());
assertThat(1)
.isEqualTo(
workBasketService
.getWorkbasketAccessItems("k200000000000000000000000000000000000000")
.size());
accessItem.setPermAppend(true);
workBasketService.updateWorkbasketAccessItem(accessItem);
if (TaskanaEngineConfiguration.shouldUseLowerCaseForAccessIds()) {
assertEquals("zaphod beeblebrox", accessItem.getAccessId());
assertThat(accessItem.getAccessId()).isEqualTo("zaphod beeblebrox");
} else {
assertEquals("Zaphod Beeblebrox", accessItem.getAccessId());
assertThat(accessItem.getAccessId()).isEqualTo("Zaphod Beeblebrox");
}
}

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

@ -1,7 +1,6 @@
package pro.taskana.workbasket.internal;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.Connection;
import java.sql.SQLException;
@ -121,17 +120,14 @@ class WorkbasketServiceImplIntExplicitTest {
List<WorkbasketSummary> distributionTargets =
workBasketService.getDistributionTargets(foundBasket.getId());
assertEquals(1, distributionTargets.size());
assertEquals(workbasket3.getId(), distributionTargets.get(0).getId());
assertNotEquals(
workBasketService.getWorkbasket(id2).getCreated(),
workBasketService.getWorkbasket(id2).getModified());
assertEquals(
workBasketService.getWorkbasket(id1).getCreated(),
workBasketService.getWorkbasket(id1).getModified());
assertEquals(
workBasketService.getWorkbasket(id3).getCreated(),
workBasketService.getWorkbasket(id3).getModified());
assertThat(distributionTargets).hasSize(1);
assertThat(distributionTargets.get(0).getId()).isEqualTo(workbasket3.getId());
assertThat(workBasketService.getWorkbasket(id2).getCreated())
.isNotEqualTo(workBasketService.getWorkbasket(id2).getModified());
assertThat(workBasketService.getWorkbasket(id1).getCreated())
.isEqualTo(workBasketService.getWorkbasket(id1).getModified());
assertThat(workBasketService.getWorkbasket(id3).getCreated())
.isEqualTo(workBasketService.getWorkbasket(id3).getModified());
connection.commit();
}
}
@ -156,7 +152,7 @@ class WorkbasketServiceImplIntExplicitTest {
accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(1, workBasketService.getWorkbasketAccessItems("id1").size());
assertThat(workBasketService.getWorkbasketAccessItems("id1")).hasSize(1);
connection.commit();
}
}
@ -182,8 +178,8 @@ class WorkbasketServiceImplIntExplicitTest {
accessItem.setPermRead(true);
workBasketService.createWorkbasketAccessItem(accessItem);
assertEquals(1, workBasketService.getWorkbasketAccessItems("key2").size());
assertEquals("zaphod beeblebrox", accessItem.getAccessId());
assertThat(workBasketService.getWorkbasketAccessItems("key2")).hasSize(1);
assertThat(accessItem.getAccessId()).isEqualTo("zaphod beeblebrox");
connection.commit();
}
}

51
lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/WorkbasketServiceImplTest.java
View File

@ -1,12 +1,8 @@
package pro.taskana.workbasket.internal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.startsWith;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNot.not;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
@ -23,7 +19,7 @@ import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import org.junit.jupiter.api.Assertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -114,10 +110,10 @@ class WorkbasketServiceImplTest {
internalTaskanaEngineMock,
taskanaEngine,
taskanaEngineConfigurationMock);
assertThat(actualWb.getId(), not(equalTo(null)));
assertThat(actualWb.getId(), startsWith("WBI"));
assertThat(actualWb.getCreated(), not(equalTo(null)));
assertThat(actualWb.getModified(), not(equalTo(null)));
assertThat(actualWb.getId()).isNotNull();
assertThat(actualWb.getId()).startsWith("WBI");
assertThat(actualWb.getCreated()).isNotNull();
assertThat(actualWb.getModified()).isNotNull();
}
@Test
@ -129,14 +125,15 @@ class WorkbasketServiceImplTest {
workbasketServiceSpy.createWorkbasket(expectedWb);
doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(eq(expectedWb.getId()));
WorkbasketNotFoundException e =
Assertions.assertThrows(
WorkbasketNotFoundException.class,
() -> workbasketServiceSpy.setDistributionTargets(expectedWb.getId(), destinations));
Assertions.assertEquals(e.getId(), otherWorkbasketId);
Assertions.assertNull(e.getKey());
Assertions.assertNull(e.getDomain());
ThrowingCallable call =
() -> {
workbasketServiceSpy.setDistributionTargets(expectedWb.getId(), destinations);
};
assertThatThrownBy(call)
.isInstanceOf(WorkbasketNotFoundException.class)
.hasFieldOrPropertyWithValue("id", otherWorkbasketId)
.hasFieldOrPropertyWithValue("key", null)
.hasFieldOrPropertyWithValue("domain", null);
verify(internalTaskanaEngineMock, times(3)).openConnection();
verify(workbasketMapperMock, times(1)).insert(expectedWb);
@ -165,8 +162,11 @@ class WorkbasketServiceImplTest {
void testDeleteWorkbasketIsUsed() throws NotAuthorizedException, WorkbasketNotFoundException {
Workbasket wb = createTestWorkbasket("WBI:0", "wb-key");
Assertions.assertThrows(
WorkbasketNotFoundException.class, () -> workbasketServiceSpy.deleteWorkbasket(wb.getId()));
ThrowingCallable call =
() -> {
workbasketServiceSpy.deleteWorkbasket(wb.getId());
};
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
verify(internalTaskanaEngineMock, times(2)).openConnection();
verify(workbasketServiceSpy, times(1)).getWorkbasket(wb.getId());
@ -207,15 +207,14 @@ class WorkbasketServiceImplTest {
oldWb.setModified(expectedModifiedTimestamp);
workbasketImplToUpdate.setModified(expectedModifiedTimestamp);
assertThatCode(
() -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate))
.doesNotThrowAnyException();
ThrowingCallable call =
() -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate);
assertThatCode(call).doesNotThrowAnyException();
workbasketImplToUpdate.setModified(expectedModifiedTimestamp.minus(1, ChronoUnit.HOURS));
assertThatExceptionOfType(ConcurrencyException.class)
.isThrownBy(
() -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate));
call = () -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate);
assertThatThrownBy(call).isInstanceOf(ConcurrencyException.class);
}
private WorkbasketImpl createTestWorkbasket(String id, String key) {

3
lib/taskana-core/src/test/java/pro/taskana/workbasket/api/models/WorkbasketModelsCloneTest.java → lib/taskana-core/src/test/java/pro/taskana/workbasket/internal/models/WorkbasketModelsCloneTest.java
View File

@ -1,9 +1,10 @@
package pro.taskana.workbasket.api.models;
package pro.taskana.workbasket.internal.models;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Test;
import pro.taskana.workbasket.api.models.Workbasket;
import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
import pro.taskana.workbasket.internal.models.WorkbasketImpl;
import pro.taskana.workbasket.internal.models.WorkbasketSummaryImpl;

Some files were not shown because too many files have changed in this diff Show More