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

TSK-1318: replaced all declared Exceptions with Exception.class in all our test classes

This commit is contained in:
Mustapha Zorgati 2020-07-02 06:24:19 +02:00
parent dd7598443a
commit ec483ab21c
103 changed files with 823 additions and 1687 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

121
history/taskana-simplehistory-provider/src/test/java/acceptance/AbstractAccTest.java
View File

@ -6,7 +6,6 @@ import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.Objects;
import java.util.Properties;
import javax.sql.DataSource;
@ -23,21 +22,20 @@ import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
public abstract class AbstractAccTest {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractAccTest.class);
private static final String USER_HOME_DIRECTORY = System.getProperty("user.home");
private static final int POOL_TIME_TO_WAIT = 50;
private static final DataSource DATA_SOURCE;
private static SimpleHistoryServiceImpl historyService;
private static DataSource dataSource;
private static String schemaName = null;
private static String schemaName;
static {
String userHomeDirectroy = System.getProperty("user.home");
String propertiesFileName = userHomeDirectroy + "/taskanaUnitTest.properties";
String propertiesFileName = USER_HOME_DIRECTORY + "/taskanaUnitTest.properties";
File f = new File(propertiesFileName);
if (f.exists() && !f.isDirectory()) {
dataSource = createDataSourceFromProperties(propertiesFileName);
DATA_SOURCE = createDataSourceFromProperties(propertiesFileName);
} else {
dataSource = createDefaultDataSource();
DATA_SOURCE = createDefaultDataSource();
}
}
@ -45,58 +43,6 @@ public abstract class AbstractAccTest {
// not called
}
@BeforeAll
public static void setupTest() throws Exception {
resetDb(null);
}
public static void resetDb(String schemaName) throws SQLException {
DataSource dataSource = getDataSource();
TaskanaEngineConfiguration taskanaEngineConfiguration =
new TaskanaEngineConfiguration(
dataSource,
false,
schemaName != null && !schemaName.isEmpty() ? schemaName : getSchemaName());
historyService = new SimpleHistoryServiceImpl();
historyService.initialize(taskanaEngineConfiguration);
DbWriter writer = new DbWriter();
writer.clearDB(dataSource);
writer.generateTestData(dataSource);
}
public static DataSource getDataSource() {
if (dataSource == null) {
throw new RuntimeException("Datasource should be already initialized");
}
return dataSource;
}
/**
* returns the SchemaName used for Junit test. If the file {user.home}/taskanaUnitTest.properties
* is present, the SchemaName is created according to the property schemaName. a sample properties
* file for DB2 looks as follows: jdbcDriver=com.ibm.db2.jcc.DB2Driver
* jdbcUrl=jdbc:db2://localhost:50000/tskdb dbUserName=db2user dbPassword=db2password
* schemaName=TASKANA If any of these properties is missing, or the file doesn't exist, the
* default schemaName TASKANA is created used.
*
* @return String for unit test
*/
public static String getSchemaName() {
if (schemaName == null) {
String userHomeDirectroy = System.getProperty("user.home");
String propertiesFileName = userHomeDirectroy + "/taskanaUnitTest.properties";
File f = new File(propertiesFileName);
if (f.exists() && !f.isDirectory()) {
schemaName = getSchemaNameFromPropertiesObject(propertiesFileName);
} else {
schemaName = "TASKANA";
}
}
return schemaName;
}
/**
* create historyEvent object.
*
@ -123,10 +69,61 @@ public abstract class AbstractAccTest {
return historyEvent;
}
public static SimpleHistoryServiceImpl getHistoryService() {
protected static void resetDb(String schemaName) throws Exception {
DataSource dataSource = getDataSource();
TaskanaEngineConfiguration taskanaEngineConfiguration =
new TaskanaEngineConfiguration(
dataSource,
false,
schemaName != null && !schemaName.isEmpty() ? schemaName : getSchemaName());
historyService = new SimpleHistoryServiceImpl();
historyService.initialize(taskanaEngineConfiguration);
DbWriter writer = new DbWriter();
writer.clearDB(dataSource);
writer.generateTestData(dataSource);
}
protected static DataSource getDataSource() {
if (DATA_SOURCE == null) {
throw new RuntimeException("Datasource should be already initialized");
}
return DATA_SOURCE;
}
/**
* returns the SchemaName used for Junit test. If the file {user.home}/taskanaUnitTest.properties
* is present, the SchemaName is created according to the property schemaName. a sample properties
* file for DB2 looks as follows: jdbcDriver=com.ibm.db2.jcc.DB2Driver
* jdbcUrl=jdbc:db2://localhost:50000/tskdb dbUserName=db2user dbPassword=db2password
* schemaName=TASKANA If any of these properties is missing, or the file doesn't exist, the
* default schemaName TASKANA is created used.
*
* @return String for unit test
*/
protected static String getSchemaName() {
if (schemaName == null) {
String propertiesFileName = USER_HOME_DIRECTORY + "/taskanaUnitTest.properties";
File f = new File(propertiesFileName);
if (f.exists() && !f.isDirectory()) {
schemaName = getSchemaNameFromPropertiesObject(propertiesFileName);
} else {
schemaName = "TASKANA";
}
}
return schemaName;
}
protected static SimpleHistoryServiceImpl getHistoryService() {
return historyService;
}
@BeforeAll
static void setupTest() throws Exception {
resetDb(null);
}
/**
* create Default DataSource for in-memory database.
*

6
history/taskana-simplehistory-provider/src/test/java/acceptance/events/GetHistoryEventAccTest.java
View File

@ -6,13 +6,11 @@ import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Test;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
import pro.taskana.spi.history.api.exceptions.TaskanaHistoryEventNotFoundException;
public class GetHistoryEventAccTest extends AbstractAccTest {
class GetHistoryEventAccTest extends AbstractAccTest {
@Test
public void should_ReturnSpecificTaskHistoryEventWithDetails_For_HistoryEventId()
throws TaskanaHistoryEventNotFoundException {
void should_ReturnSpecificTaskHistoryEventWithDetails_For_HistoryEventId() throws Exception {
String detailsJson =
"{\"changes\":[{"

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

@ -16,14 +16,14 @@ import pro.taskana.simplehistory.query.HistoryQueryColumnName;
import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
/** Test for History queries. */
public class QueryHistoryAccTest extends AbstractAccTest {
class QueryHistoryAccTest extends AbstractAccTest {
public QueryHistoryAccTest() {
super();
}
@Test
public void should_ConfirmEquality_When_UsingListValuesAscendingAndDescending() {
void should_ConfirmEquality_When_UsingListValuesAscendingAndDescending() {
List<String> defaultList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.CREATED, null);
List<String> ascendingList =
@ -44,7 +44,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnHistoryEvents_For_ComplexQuery() {
void should_ReturnHistoryEvents_For_ComplexQuery() {
HistoryQuery query =
getHistoryService()
.createHistoryQuery()
@ -64,7 +64,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
void should_ConfirmQueryListOffset_When_ProvidingOffsetAndLimit() {
List<HistoryEventImpl> result = getHistoryService().createHistoryQuery().list(1, 2);
List<HistoryEventImpl> wrongList = getHistoryService().createHistoryQuery().list();
@ -74,7 +74,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnEmptyList_When_ProvidingWrongContraints() {
void should_ReturnEmptyList_When_ProvidingWrongContraints() {
List<HistoryEventImpl> result = getHistoryService().createHistoryQuery().list(1, 1000);
assertThat(result).hasSize(2);
@ -83,7 +83,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
void should_ReturnSingleHistoryEvent_When_UsingSingleMethod() {
HistoryEventImpl single = getHistoryService().createHistoryQuery().userIdIn("peter").single();
assertThat(single.getEventType()).isEqualTo("TASK_CREATED");
@ -92,7 +92,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnCountOfEvents_When_UsingCountMethod() {
void should_ReturnCountOfEvents_When_UsingCountMethod() {
long count = getHistoryService().createHistoryQuery().userIdIn("peter").count();
assertThat(count).isOne();
@ -104,7 +104,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnHistoryEvents_For_DifferentInAttributes() {
void should_ReturnHistoryEvents_For_DifferentInAttributes() {
List<HistoryEventImpl> returnValues =
getHistoryService().createHistoryQuery().businessProcessIdIn("BPI:01", "BPI:02").list();
assertThat(returnValues).hasSize(2);
@ -196,7 +196,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
void should_ReturnHistoryEvents_For_DifferentLikeAttributes() {
List<HistoryEventImpl> returnValues =
getHistoryService().createHistoryQuery().businessProcessIdLike("BPI:0%").list();
assertThat(returnValues).hasSize(3);
@ -217,7 +217,7 @@ public class QueryHistoryAccTest extends AbstractAccTest {
}
@Test
public void should_ReturnHistoryEvents_When_ProvidingListValues() {
void should_ReturnHistoryEvents_When_ProvidingListValues() {
List<String> returnedList =
getHistoryService().createHistoryQuery().listValues(HistoryQueryColumnName.ID, null);
assertThat(returnedList).hasSize(3);

7
history/taskana-simplehistory-provider/src/test/java/configuration/TaskanaEngineConfigurationTest.java
View File

@ -3,7 +3,6 @@ package configuration;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.junit.jupiter.api.Test;
@ -15,10 +14,10 @@ import pro.taskana.common.api.TaskanaEngine;
*
* @author MMR
*/
public class TaskanaEngineConfigurationTest extends AbstractAccTest {
class TaskanaEngineConfigurationTest extends AbstractAccTest {
@Test
public void testCreateTaskanaEngine() throws SQLException {
void testCreateTaskanaEngine() throws Exception {
DataSource ds = getDataSource();
TaskanaEngineConfiguration taskEngineConfiguration =
new TaskanaEngineConfiguration(ds, false, getSchemaName());
@ -29,7 +28,7 @@ public class TaskanaEngineConfigurationTest extends AbstractAccTest {
}
@Test
public void testCreateTaskanaHistoryEventWithNonDefaultSchemaName() throws SQLException {
void testCreateTaskanaHistoryEventWithNonDefaultSchemaName() throws Exception {
resetDb("SOMECUSTOMSCHEMANAME");
long count = getHistoryService().createHistoryQuery().workbasketKeyIn("wbKey1").count();
assertThat(count).isZero();

7
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/HistoryQueryImplTest.java
View File

@ -5,7 +5,6 @@ import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.validateMockitoUsage;
import java.sql.SQLException;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
@ -24,7 +23,7 @@ import pro.taskana.simplehistory.impl.mappings.HistoryQueryMapper;
* @author BV
*/
@ExtendWith(MockitoExtension.class)
public class HistoryQueryImplTest {
class HistoryQueryImplTest {
private HistoryQueryImpl historyQueryImpl;
@ -33,12 +32,12 @@ public class HistoryQueryImplTest {
@Mock private HistoryQueryMapper historyQueryMock;
@BeforeEach
public void setup() {
void setup() {
historyQueryImpl = new HistoryQueryImpl(taskanaHistoryEngineMock, historyQueryMock);
}
@Test
public void testShouldReturnList() throws SQLException {
void testShouldReturnList() throws Exception {
List<HistoryEventImpl> returnList = new ArrayList<>();
returnList.add(createHistoryEvent("abcd", "T22", "car", "BV", "this was important", null));
TimeInterval interval = new TimeInterval(Instant.now().minusNanos(1000), Instant.now());

5
history/taskana-simplehistory-provider/src/test/java/pro/taskana/simplehistory/impl/SimpleHistoryServiceImplTest.java
View File

@ -8,7 +8,6 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.ibatis.session.SqlSessionManager;
@ -54,7 +53,7 @@ class SimpleHistoryServiceImplTest {
}
@Test
void testCreateEvent() throws SQLException {
void testCreateEvent() throws Exception {
HistoryEventImpl expectedWb =
AbstractAccTest.createHistoryEvent(
"wbKey1", "taskId1", "type1", "wbKey2", "someUserId", "someDetails");
@ -67,7 +66,7 @@ class SimpleHistoryServiceImplTest {
}
@Test
void testQueryEvent() throws SQLException {
void testQueryEvent() throws Exception {
List<HistoryEventImpl> returnList = new ArrayList<>();
returnList.add(
AbstractAccTest.createHistoryEvent(

16
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/TaskHistoryEventControllerIntTest.java
View File

@ -35,7 +35,7 @@ import pro.taskana.simplehistory.rest.resource.TaskHistoryEventResource;
@SpringBootTest(
classes = {TaskHistoryRestConfiguration.class},
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class TaskHistoryEventControllerIntTest {
class TaskHistoryEventControllerIntTest {
@Value("${taskana.schemaName:TASKANA}")
public String schemaName;
@ -49,7 +49,7 @@ public class TaskHistoryEventControllerIntTest {
@LocalServerPort int port;
@Test
public void testGetAllHistoryEvent() {
void testGetAllHistoryEvent() {
ResponseEntity<TaskHistoryEventListResource> response =
template.exchange(
server + port + "/api/v1/task-history-event",
@ -61,7 +61,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void testGetAllHistoryEventDescendingOrder() {
void testGetAllHistoryEventDescendingOrder() {
String parameters =
"/api/v1/task-history-event?sort-by=business-process-id&order=desc&page-size=3&page=1";
ResponseEntity<TaskHistoryEventListResource> response =
@ -82,7 +82,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void should_ReturnSpecificTaskHistoryEventWithoutDetails_When_ListIsQueried() {
void should_ReturnSpecificTaskHistoryEventWithoutDetails_When_ListIsQueried() {
ResponseEntity<TaskHistoryEventListResource> response =
template.exchange(
server
@ -101,7 +101,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void should_ReturnSpecificTaskHistoryEventWithDetails_When_SingleEventIsQueried() {
void should_ReturnSpecificTaskHistoryEventWithDetails_When_SingleEventIsQueried() {
ResponseEntity<TaskHistoryEventResource> response =
template.exchange(
server + port + "/api/v1/task-history-event/45",
@ -115,7 +115,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void testThrowsExceptionIfInvalidFilterIsUsed() {
void testThrowsExceptionIfInvalidFilterIsUsed() {
ThrowingCallable httpCall =
() -> {
template.exchange(
@ -132,7 +132,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void testGetHistoryEventOfDate() {
void testGetHistoryEventOfDate() {
String currentTime = LocalDateTime.now().toString();
final String finalCurrentTime = currentTime;
ThrowingCallable httpCall =
@ -162,7 +162,7 @@ public class TaskHistoryEventControllerIntTest {
}
@Test
public void testGetSecondPageSortedByKey() {
void testGetSecondPageSortedByKey() {
String parameters =
"/api/v1/task-history-event?sort-by=workbasket-key&order=desc&page=2&page-size=2";
ResponseEntity<TaskHistoryEventListResource> response =

4
history/taskana-simplehistory-rest-spring/src/test/java/pro/taskana/TaskHistoryEventResourceAssemblerTest.java
View File

@ -20,12 +20,12 @@ import pro.taskana.spi.history.api.events.TaskanaHistoryEvent;
@SpringBootTest(
classes = {TaskHistoryRestConfiguration.class},
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class TaskHistoryEventResourceAssemblerTest {
class TaskHistoryEventResourceAssemblerTest {
private final TaskHistoryEventResourceAssembler taskHistoryEventResourceAssembler;
@Autowired
public TaskHistoryEventResourceAssemblerTest(
TaskHistoryEventResourceAssemblerTest(
TaskHistoryEventResourceAssembler taskHistoryEventResourceAssembler) {
this.taskHistoryEventResourceAssembler = taskHistoryEventResourceAssembler;
}

26
lib/taskana-cdi/src/test/java/pro/taskana/TaskanaRestTest.java
View File

@ -12,22 +12,10 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
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.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
/** TODO. */
@ -41,11 +29,7 @@ public class TaskanaRestTest {
@Inject private ClassificationService classificationService;
@GET
public Response startTask()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
ClassificationAlreadyExistException, InvalidWorkbasketException,
TaskAlreadyExistException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException {
public Response startTask() throws Exception {
Workbasket workbasket = taskanaEjb.getWorkbasketService().newWorkbasket("key", "cdiDomain");
workbasket.setName("wb");
workbasket.setType(WorkbasketType.PERSONAL);
@ -71,18 +55,14 @@ public class TaskanaRestTest {
}
@POST
public Response rollbackTask()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
TaskAlreadyExistException, InvalidArgumentException {
public Response rollbackTask() throws Exception {
taskanaEjb.triggerRollback();
return Response.status(204).build();
}
@DELETE
@Path("{id}")
public void completeTask(@PathParam("id") String id)
throws TaskNotFoundException, InvalidOwnerException, InvalidStateException,
NotAuthorizedException {
public void completeTask(@PathParam("id") String id) throws Exception {
LOGGER.info(id);
taskanaEjb.getTaskService().forceCompleteTask(id);
}

7
lib/taskana-cdi/src/test/java/pro/taskana/common/internal/TaskanaProducersTest.java
View File

@ -3,7 +3,6 @@ package pro.taskana.common.internal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
@ -36,7 +35,7 @@ public class TaskanaProducersTest {
}
@Test
public void testCommit() throws SQLException, ClassNotFoundException {
public void testCommit() throws Exception {
Client client = ClientBuilder.newClient();
client.target("http://127.0.0.1:8090/rest/test").request().get();
@ -56,7 +55,7 @@ public class TaskanaProducersTest {
}
@Test
public void testRollback() throws SQLException, ClassNotFoundException {
public void testRollback() throws Exception {
Client client = ClientBuilder.newClient();
client.target("http://127.0.0.1:8090/rest/test").request().post(null);
@ -75,7 +74,7 @@ public class TaskanaProducersTest {
Assert.assertEquals(0, resultCount);
}
private Connection getConnection() throws SQLException {
private Connection getConnection() throws Exception {
return DriverManager.getConnection(
"jdbc:h2:~/taskana-h2-data/testdb;AUTO_SERVER=TRUE;IGNORECASE=TRUE;LOCK_MODE=0",
"SA",

37
lib/taskana-core/src/main/java/pro/taskana/task/internal/models/MinimalTaskSummary.java
View File

@ -1,6 +1,7 @@
package pro.taskana.task.internal.models;
import java.time.Instant;
import java.util.Objects;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.TaskState;
@ -101,6 +102,42 @@ public class MinimalTaskSummary {
this.callbackState = callbackState;
}
@Override
public int hashCode() {
return Objects.hash(
taskId,
externalId,
workbasketId,
classificationId,
owner,
taskState,
planned,
due,
modified,
callbackState);
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof MinimalTaskSummary)) {
return false;
}
MinimalTaskSummary other = (MinimalTaskSummary) obj;
return Objects.equals(taskId, other.taskId)
&& Objects.equals(externalId, other.externalId)
&& Objects.equals(workbasketId, other.workbasketId)
&& Objects.equals(classificationId, other.classificationId)
&& Objects.equals(owner, other.owner)
&& taskState == other.taskState
&& Objects.equals(planned, other.planned)
&& Objects.equals(due, other.due)
&& Objects.equals(modified, other.modified)
&& callbackState == other.callbackState;
}
@Override
public String toString() {
return "MinimalTaskSummary [taskId="

12
lib/taskana-core/src/test/java/acceptance/AbstractAccTest.java
View File

@ -1,6 +1,5 @@
package acceptance;
import java.sql.SQLException;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
@ -16,7 +15,6 @@ import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeAll;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.TimeInterval;
@ -33,17 +31,17 @@ public abstract class AbstractAccTest {
"cn=Organisationseinheit KSC 1,cn=Organisationseinheit KSC,cn=organisation,OU=Test,O=TASKANA";
public static final String GROUP_2_DN =
"cn=Organisationseinheit KSC 2,cn=Organisationseinheit KSC,cn=organisation,OU=Test,O=TASKANA";
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
protected static WorkingDaysToDaysConverter converter;
@BeforeAll
public static void setupTest() throws Exception {
protected static void setupTest() throws Exception {
resetDb(false);
}
public static void resetDb(boolean dropTables) throws SQLException {
protected static void resetDb(boolean dropTables) throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
@ -84,7 +82,7 @@ public abstract class AbstractAccTest {
String channel,
String receivedDate,
Map<String, String> customAttributes)
throws ClassificationNotFoundException {
throws Exception {
Attachment attachment = taskanaEngine.getTaskService().newAttachment();
attachment.setClassificationSummary(
@ -94,7 +92,7 @@ public abstract class AbstractAccTest {
.asSummary());
attachment.setObjectReference(objRef);
attachment.setChannel(channel);
Instant receivedTimestamp = null;
final Instant receivedTimestamp;
if (receivedDate != null && receivedDate.length() < 11) {
// contains only the date, not the time
LocalDate date = LocalDate.parse(receivedDate);

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

@ -1,19 +0,0 @@
package acceptance;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import org.junit.jupiter.api.Test;
import pro.taskana.task.api.exceptions.UpdateFailedException;
public class UpdateFaileExceptionTest {
@Test
void testUpdateFailedException() {
final UpdateFailedException exception = new UpdateFailedException("for test");
assertThatThrownBy(() -> throwit()).isInstanceOf(UpdateFailedException.class);
}
void throwit() throws UpdateFailedException {
throw new UpdateFailedException("for coverage");
}
}

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

@ -11,13 +11,11 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -36,9 +34,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateMasterClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
void testCreateMasterClassification() throws Exception {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key0", "", "TASK");
classification.setIsValidInDomain(true);
@ -60,9 +56,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateClassificationWithMasterCopy()
throws ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
void testCreateClassificationWithMasterCopy() throws Exception {
final long countClassificationsBefore =
classificationService.createClassificationQuery().count();
Classification classification =
@ -107,9 +101,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateClassificationWithExistingMaster()
throws DomainNotFoundException, ClassificationAlreadyExistException, NotAuthorizedException,
InvalidArgumentException {
void testCreateClassificationWithExistingMaster() throws Exception {
classificationService.createClassification(
classificationService.newClassification("Key0815", "", "TASK"));
@ -128,7 +120,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateChildInDomainAndCopyInMaster() throws TaskanaException {
void testCreateChildInDomainAndCopyInMaster() throws Exception {
Classification parent = classificationService.newClassification("Key0816", "DOMAIN_A", "TASK");
Classification actualParent = classificationService.createClassification(parent);
assertThat(actualParent).isNotNull();
@ -166,7 +158,7 @@ class CreateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateClassificationAlreadyExisting() throws TaskanaException {
void testCreateClassificationAlreadyExisting() throws Exception {
Classification classification = classificationService.newClassification("Key3", "", "TASK");
Classification classificationCreated =
classificationService.createClassification(classification);

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

@ -30,8 +30,7 @@ class DeleteClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteClassificationInDomain()
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException {
void testDeleteClassificationInDomain() throws Exception {
classificationService.deleteClassification("L140101", "DOMAIN_A");
Classification classification = classificationService.getClassification("L140101", "DOMAIN_A");
@ -70,8 +69,7 @@ class DeleteClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteMasterClassification()
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException {
void testDeleteMasterClassification() throws Exception {
classificationService.deleteClassification("L3060", "");
ThrowingCallable call = () -> classificationService.getClassification("L3060", "DOMAIN_A");
@ -87,8 +85,7 @@ class DeleteClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testThrowExceptionWhenChildClassificationIsInUseAndRollback()
throws ClassificationNotFoundException {
void testThrowExceptionWhenChildClassificationIsInUseAndRollback() throws Exception {
ThrowingCallable call = () -> classificationService.deleteClassification("L11010", "DOMAIN_A");
assertThatThrownBy(call).isInstanceOf(ClassificationInUseException.class);

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

@ -31,7 +31,7 @@ class GetClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetOneClassificationByKeyAndDomain() throws ClassificationNotFoundException {
void testGetOneClassificationByKeyAndDomain() throws Exception {
Classification classification = classificationService.getClassification("T6310", "DOMAIN_A");
assertThat(classification).isNotNull();
assertThat(classification.getId()).isEqualTo("CLI:100000000000000000000000000000000011");
@ -54,7 +54,7 @@ class GetClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetOneClassificationById() throws ClassificationNotFoundException {
void testGetOneClassificationById() throws Exception {
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000011");
assertThat(classification).isNotNull();
@ -79,14 +79,14 @@ class GetClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetClassificationWithSpecialCharacter() throws ClassificationNotFoundException {
void testGetClassificationWithSpecialCharacter() throws Exception {
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000009");
assertThat(classification.getName()).isEqualTo("Zustimmungserklärung");
}
@Test
void testGetClassificationAsSummary() throws ClassificationNotFoundException {
void testGetClassificationAsSummary() throws Exception {
ClassificationSummary classification =
classificationService
.getClassification("CLI:100000000000000000000000000000000011")
@ -125,8 +125,7 @@ class GetClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetOneClassificationForDomainAndGetClassificationFromMasterDomain()
throws ClassificationNotFoundException {
void testGetOneClassificationForDomainAndGetClassificationFromMasterDomain() throws Exception {
Classification classification = classificationService.getClassification("L10000", "DOMAIN_B");
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");
@ -134,7 +133,7 @@ class GetClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetOneClassificationForMasterDomain() throws ClassificationNotFoundException {
void testGetOneClassificationForMasterDomain() throws Exception {
Classification classification = classificationService.getClassification("L10000", "");
assertThat(classification).isNotNull();
assertThat(classification.getDomain()).isEqualTo("");

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

@ -21,12 +21,8 @@ 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.TimeInterval;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -174,7 +170,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetClassificationsWithCustom1() throws InvalidArgumentException {
void testGetClassificationsWithCustom1() throws Exception {
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -185,7 +181,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetClassificationsWithCustom1Like() throws InvalidArgumentException {
void testGetClassificationsWithCustom1Like() throws Exception {
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -197,7 +193,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testGetClassificationsWithParentAndCustom2() throws InvalidArgumentException {
void testGetClassificationsWithParentAndCustom2() throws Exception {
List<ClassificationSummary> classifications =
classificationService
.createClassificationQuery()
@ -234,9 +230,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testFindClassificationByModifiedWithin()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException {
void testFindClassificationByModifiedWithin() throws Exception {
String clId = "CLI:200000000000000000000000000000000015";
classificationService.updateClassification(classificationService.getClassification(clId));
@ -310,7 +304,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom1In() throws InvalidArgumentException {
void testQueryForCustom1In() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -320,7 +314,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom2In() throws InvalidArgumentException {
void testQueryForCustom2In() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -330,7 +324,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom3In() throws InvalidArgumentException {
void testQueryForCustom3In() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -340,28 +334,28 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom4In() throws InvalidArgumentException {
void testQueryForCustom4In() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("4", "custom4").list();
assertThat(results).hasSize(5);
}
@Test
void testQueryForCustom5In() throws InvalidArgumentException {
void testQueryForCustom5In() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("5", "custom5").list();
assertThat(results).hasSize(5);
}
@Test
void testQueryForCustom6In() throws InvalidArgumentException {
void testQueryForCustom6In() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeIn("6", "custom6").list();
assertThat(results).hasSize(5);
}
@Test
void testQueryForCustom7In() throws InvalidArgumentException {
void testQueryForCustom7In() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -371,7 +365,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom8In() throws InvalidArgumentException {
void testQueryForCustom8In() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -381,49 +375,49 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForCustom2Like() throws InvalidArgumentException {
void testQueryForCustom2Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("2", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom3Like() throws InvalidArgumentException {
void testQueryForCustom3Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("3", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom4Like() throws InvalidArgumentException {
void testQueryForCustom4Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("4", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom5Like() throws InvalidArgumentException {
void testQueryForCustom5Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("5", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom6Like() throws InvalidArgumentException {
void testQueryForCustom6Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("6", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom7Like() throws InvalidArgumentException {
void testQueryForCustom7Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("7", "cus%").list();
assertThat(results).hasSize(6);
}
@Test
void testQueryForCustom8Like() throws InvalidArgumentException {
void testQueryForCustom8Like() throws Exception {
List<ClassificationSummary> results =
classificationService.createClassificationQuery().customAttributeLike("8", "cus%").list();
assertThat(results).hasSize(6);
@ -552,7 +546,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom1Desc() throws InvalidArgumentException {
void testQueryForOrderByCustom1Desc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -566,7 +560,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom2Asc() throws InvalidArgumentException {
void testQueryForOrderByCustom2Asc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -580,7 +574,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom3Desc() throws InvalidArgumentException {
void testQueryForOrderByCustom3Desc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -594,7 +588,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom4Asc() throws InvalidArgumentException {
void testQueryForOrderByCustom4Asc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -608,7 +602,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom5Desc() throws InvalidArgumentException {
void testQueryForOrderByCustom5Desc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -622,7 +616,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom6Asc() throws InvalidArgumentException {
void testQueryForOrderByCustom6Asc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -636,7 +630,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom7Desc() throws InvalidArgumentException {
void testQueryForOrderByCustom7Desc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()
@ -650,7 +644,7 @@ class QueryClassificationAccTest extends AbstractAccTest {
}
@Test
void testQueryForOrderByCustom8Asc() throws InvalidArgumentException {
void testQueryForOrderByCustom8Asc() throws Exception {
List<ClassificationSummary> results =
classificationService
.createClassificationQuery()

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

@ -27,7 +27,6 @@ import pro.taskana.common.internal.jobs.JobRunner;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.models.TaskImpl;
@ -40,9 +39,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateClassification()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException {
void testUpdateClassification() throws Exception {
String newName = "updated Name";
String newEntryPoint = "updated EntryPoint";
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
@ -80,7 +77,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
}
@Test
void should_ThrowException_When_UserIsNotAuthorized() throws ClassificationNotFoundException {
void should_ThrowException_When_UserIsNotAuthorized() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setCustom1("newCustom1");
ThrowingCallable call = () -> classificationService.updateClassification(classification);
@ -90,8 +87,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@WithAccessId(user = "user-1-1")
@TestTemplate
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin()
throws ClassificationNotFoundException {
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
@ -135,9 +131,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateClassificationNotLatestAnymore()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InterruptedException, InvalidArgumentException {
void testUpdateClassificationNotLatestAnymore() throws Exception {
Classification base = classificationService.getClassification("T2100", "DOMAIN_A");
final Classification classification =
classificationService.getClassification("T2100", "DOMAIN_A");
@ -157,7 +151,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateClassificationParentIdToInvalid() throws ClassificationNotFoundException {
void testUpdateClassificationParentIdToInvalid() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentId("ID WHICH CANT BE FOUND");
ThrowingCallable call = () -> classificationService.updateClassification(classification);
@ -166,7 +160,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateClassificationParentKeyToInvalid() throws ClassificationNotFoundException {
void testUpdateClassificationParentKeyToInvalid() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentKey("KEY WHICH CANT BE FOUND");
ThrowingCallable call = () -> classificationService.updateClassification(classification);
@ -175,9 +169,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testUpdateClassificationPrioServiceLevel()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InterruptedException, TaskNotFoundException, InvalidArgumentException {
void testUpdateClassificationPrioServiceLevel() throws Exception {
final Instant before = Instant.now();
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
@ -259,7 +251,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateClassificationWithSameKeyAndParentKey() throws ClassificationNotFoundException {
void testUpdateClassificationWithSameKeyAndParentKey() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
@ -283,9 +275,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testUpdateClassificationChangePriority()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InterruptedException, TaskNotFoundException, InvalidArgumentException {
void testUpdateClassificationChangePriority() throws Exception {
final Instant before = Instant.now();
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
@ -420,9 +410,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testUpdateClassificationChangeServiceLevel()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InterruptedException, TaskNotFoundException, InvalidArgumentException {
void testUpdateClassificationChangeServiceLevel() throws Exception {
final Instant before = Instant.now();
Classification classification =
classificationService.getClassification("CLI:100000000000000000000000000000000003");
@ -500,8 +488,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
}
private void updateClassificationAndRunAssociatedJobs(Classification classification)
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException, InterruptedException {
throws Exception {
classificationService.updateClassification(classification);
Thread.sleep(10);
// run the ClassificationChangedJob
@ -520,7 +507,7 @@ class UpdateClassificationAccTest extends AbstractAccTest {
WorkingDaysToDaysConverter converter,
int serviceLevel,
int priority)
throws TaskNotFoundException, NotAuthorizedException {
throws Exception {
for (String taskId : tasksUpdated) {
Task task = taskService.getTask(taskId);

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

@ -3,12 +3,10 @@ package acceptance.config;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@ -28,7 +26,7 @@ import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
*/
class TaskanaConfigAccTest extends TaskanaEngineImpl {
TaskanaConfigAccTest() throws SQLException {
TaskanaConfigAccTest() throws Exception {
super(
new TaskanaEngineConfiguration(
TaskanaEngineTestConfiguration.getDataSource(),
@ -53,7 +51,7 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
}
@Test
void testDoesNotExistPropertyClassificationTypeOrItIsEmpty() throws IOException {
void testDoesNotExistPropertyClassificationTypeOrItIsEmpty() throws Exception {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", false, true);
String delimiter = ";";
@ -66,7 +64,7 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
}
@Test
void testDoesNotExistPropertyClassificationCategoryOrItIsEmpty() throws IOException {
void testDoesNotExistPropertyClassificationCategoryOrItIsEmpty() throws Exception {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
taskanaEngineConfiguration.setClassificationCategoriesByType(new HashMap<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", true, false);
@ -83,7 +81,7 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
}
@Test
void testWithCategoriesAndClassificationFilled() throws IOException {
void testWithCategoriesAndClassificationFilled() throws Exception {
taskanaEngineConfiguration.setClassificationTypes(new ArrayList<>());
taskanaEngineConfiguration.setClassificationCategoriesByType(new HashMap<>());
String propertiesFileName = createNewConfigFile("/dummyTestConfig.properties", true, true);
@ -116,7 +114,7 @@ class TaskanaConfigAccTest extends TaskanaEngineImpl {
}
private String createNewConfigFile(
String filename, boolean addingTypes, boolean addingClassification) throws IOException {
String filename, boolean addingTypes, boolean addingClassification) throws Exception {
Path file = Files.createFile(Paths.get(System.getProperty("user.home") + filename));
List<String> lines =
Stream.of(

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

@ -3,12 +3,10 @@ package acceptance.config;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
@ -27,7 +25,7 @@ import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
*/
class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
TaskanaRoleConfigAccTest() throws SQLException {
TaskanaRoleConfigAccTest() throws Exception {
super(
new TaskanaEngineConfiguration(
TaskanaEngineTestConfiguration.getDataSource(),
@ -69,7 +67,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
}
@Test
void testOtherConfigFileSameDelimiter() throws IOException {
void testOtherConfigFileSameDelimiter() throws Exception {
String propertiesFileName = createNewConfigFileWithSameDelimiter("/dummyTestConfig.properties");
try {
getConfiguration().initTaskanaProperties(propertiesFileName, "|");
@ -95,7 +93,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
}
@Test
void testOtherConfigFileDifferentDelimiter() throws IOException {
void testOtherConfigFileDifferentDelimiter() throws Exception {
String delimiter = ";";
String propertiesFileName =
createNewConfigFileWithDifferentDelimiter("/dummyTestConfig.properties", delimiter);
@ -123,7 +121,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
}
private String createNewConfigFileWithDifferentDelimiter(String filename, String delimiter)
throws IOException {
throws Exception {
Path file = Files.createFile(Paths.get(System.getProperty("user.home") + filename));
List<String> lines =
Arrays.asList(
@ -141,7 +139,7 @@ class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
}
}
private String createNewConfigFileWithSameDelimiter(String filename) throws IOException {
private String createNewConfigFileWithSameDelimiter(String filename) throws Exception {
Path file = Files.createFile(Paths.get(System.getProperty("user.home") + filename));
List<String> lines =
Arrays.asList(

15
lib/taskana-core/src/test/java/acceptance/config/TaskanaSecurityConfigAccTest.java
View File

@ -6,7 +6,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@ -22,7 +21,7 @@ import pro.taskana.sampledata.SampleDataGenerator;
class TaskanaSecurityConfigAccTest {
@BeforeEach
void cleanDb() throws SQLException {
void cleanDb() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
@ -34,7 +33,7 @@ class TaskanaSecurityConfigAccTest {
@Test
void should_ThrowException_When_CreatingUnsecuredEngineCfgWhileSecurityIsEnforced()
throws SQLException {
throws Exception {
setSecurityFlag(true);
@ -55,7 +54,7 @@ class TaskanaSecurityConfigAccTest {
@Test
void should_StartUpNormally_When_CreatingUnsecuredEngineCfgWhileSecurityIsNotEnforced()
throws SQLException {
throws Exception {
setSecurityFlag(false);
@ -74,7 +73,7 @@ class TaskanaSecurityConfigAccTest {
@Test
void should_SetSecurityFlagToFalse_When_CreatingUnsecureEngineCfgAndSecurityFlagIsNotSet()
throws SQLException {
throws Exception {
assertThat(retrieveSecurityFlag()).isNull();
@ -95,7 +94,7 @@ class TaskanaSecurityConfigAccTest {
@Test
void should_SetSecurityFlagToTrue_When_CreatingSecureEngineCfgAndSecurityFlagIsNotSet()
throws SQLException {
throws Exception {
assertThat(retrieveSecurityFlag()).isNull();
@ -114,7 +113,7 @@ class TaskanaSecurityConfigAccTest {
assertThat(retrieveSecurityFlag()).isTrue();
}
private Boolean retrieveSecurityFlag() throws SQLException {
private Boolean retrieveSecurityFlag() throws Exception {
try (Connection connection = TaskanaEngineTestConfiguration.getDataSource().getConnection()) {
@ -133,7 +132,7 @@ class TaskanaSecurityConfigAccTest {
}
}
private void setSecurityFlag(boolean securityFlag) throws SQLException {
private void setSecurityFlag(boolean securityFlag) throws Exception {
try (Connection connection = TaskanaEngineTestConfiguration.getDataSource().getConnection()) {

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

@ -3,27 +3,18 @@ package acceptance.jobs;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
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.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.jobs.TaskCleanupJob;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance test for all "jobs tasks runner" scenarios. */
@ExtendWith(JaasExtension.class)
@ -32,7 +23,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
TaskService taskService;
@BeforeEach
void before() throws SQLException {
void before() throws Exception {
// required if single tests modify database
// TODO split test class into readOnly & modifying tests to improve performance
resetDb(false);
@ -94,10 +85,7 @@ class TaskCleanupJobAccTest extends AbstractAccTest {
assertThat(completedCreatedTask).isNotNull();
}
private Task createAndCompleteTask()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
private Task createAndCompleteTask() throws Exception {
Task newTask = taskService.newTask("user-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(

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

@ -9,7 +9,6 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
@ -33,7 +32,7 @@ class WorkbasketCleanupJobAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void shouldCleanWorkbasketMarkedForDeletionWithoutTasks() throws TaskanaException {
void shouldCleanWorkbasketMarkedForDeletionWithoutTasks() throws Exception {
long totalWorkbasketCount = workbasketService.createWorkbasketQuery().count();
assertThat(totalWorkbasketCount).isEqualTo(25);
List<WorkbasketSummary> workbaskets =

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

@ -3,7 +3,6 @@ package acceptance.persistence;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.time.Duration;
import java.time.Instant;
import java.util.Collections;
@ -13,44 +12,27 @@ 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.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.common.api.JobService;
import pro.taskana.common.api.ScheduledJob;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.JobServiceImpl;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
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.Task;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
/** Acceptance test for access to timestamps from different timezones. */
@ExtendWith(JaasExtension.class)
public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testTimestampsOnTaskUpdate()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testTimestampsOnTaskUpdate() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
Instant now = Instant.now();
@ -72,9 +54,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreatedTaskObjectEqualsReadTaskObjectInNewTimezone()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void testCreatedTaskObjectEqualsReadTaskObjectInNewTimezone() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
@ -110,9 +90,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testTimestampsOnClassificationUpdate()
throws ClassificationNotFoundException, InvalidArgumentException, ConcurrencyException,
NotAuthorizedException {
void testTimestampsOnClassificationUpdate() throws Exception {
ClassificationService classificationService = taskanaEngine.getClassificationService();
Classification classification =
classificationService.getClassification("CLI:000000000000000000000000000000000001");
@ -130,9 +108,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testTimestampsOnCreateMasterClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
void testTimestampsOnCreateMasterClassification() throws Exception {
ClassificationService classificationService = taskanaEngine.getClassificationService();
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key0", "", "TASK");
@ -154,8 +130,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testTimestampsOnWorkbasketUpdate()
throws ConcurrencyException, NotAuthorizedException, WorkbasketNotFoundException {
void testTimestampsOnWorkbasketUpdate() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket =
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000001");
@ -171,10 +146,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testTimestampsOnCreateWorkbasket()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
InvalidWorkbasketException, WorkbasketAlreadyExistException, DomainNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testTimestampsOnCreateWorkbasket() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
final int before = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();
@ -200,7 +172,7 @@ public class UpdateObjectsUseUtcTimeStampsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testTimestampsOnCreateScheduledJob() throws SQLException {
void testTimestampsOnCreateScheduledJob() throws Exception {
resetDb(true);
ScheduledJob job = new ScheduledJob();
job.setArguments(Collections.singletonMap("keyBla", "valueBla"));

13
lib/taskana-core/src/test/java/acceptance/report/AbstractReportAccTest.java
View File

@ -1,6 +1,5 @@
package acceptance.report;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeAll;
@ -18,12 +17,7 @@ public class AbstractReportAccTest {
// checkstyle needs this constructor, since this is only a "utility" class
protected AbstractReportAccTest() {}
@BeforeAll
public static void setupTest() throws Exception {
resetDb();
}
protected static void resetDb() throws SQLException {
protected static void resetDb() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, schemaName);
@ -34,4 +28,9 @@ public class AbstractReportAccTest {
sampleDataGenerator.clearDb();
sampleDataGenerator.generateMonitorData();
}
@BeforeAll
static void setupTest() throws Exception {
resetDb();
}
}

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

@ -36,7 +36,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomAttributeValuesForOneWorkbasket() throws NotAuthorizedException {
void testGetCustomAttributeValuesForOneWorkbasket() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> values =
@ -50,7 +50,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomAttributeValuesForOneDomain() throws NotAuthorizedException {
void testGetCustomAttributeValuesForOneDomain() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> values =
@ -63,7 +63,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomAttributeValuesForCustomAttribute() throws NotAuthorizedException {
void testGetCustomAttributeValuesForCustomAttribute() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
@ -81,7 +81,7 @@ class GetCustomAttributeValuesForReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomAttributeValuesForExcludedClassifications() throws NotAuthorizedException {
void testGetCustomAttributeValuesForExcludedClassifications() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Arrays.asList("DOMAIN_A", "DOMAIN_B", "DOMAIN_C");

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

@ -41,7 +41,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReport() throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReport() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -90,8 +90,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportWithWorkbasketFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<String> workbasketIds =
@ -136,8 +135,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportWithStateFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -188,8 +186,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportWithCategoryFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -226,8 +223,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportWithDomainFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<String> domains = Collections.singletonList("DOMAIN_A");
@ -271,8 +267,7 @@ class GetTaskIdsOfCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCategoryReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportWithCustomFieldValueFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -9,7 +9,6 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -56,8 +55,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfClassificationReport() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -101,8 +99,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfClassificationReportWithAttachments()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfClassificationReportWithAttachments() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -143,8 +140,7 @@ class GetTaskIdsOfClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfClassificationReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfClassificationReportWithDomainFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();

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

@ -44,8 +44,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReport() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -91,8 +90,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReportWithWorkbasketFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<String> workbasketIds =
@ -136,8 +134,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReportWithStateFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -183,8 +180,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReportWithCategoryFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -226,8 +222,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReportWithDomainFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -268,8 +263,7 @@ class GetTaskIdsOfCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfCustomFieldValueReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -10,7 +10,6 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -37,7 +36,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfWorkbasketReport() throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfWorkbasketReport() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -82,8 +81,7 @@ class GetTaskIdsOfWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTaskIdsOfWorkbasketReportWithExcludedClassifications()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfWorkbasketReportWithExcludedClassifications() throws Exception {
final MonitorService monitorService = taskanaEngine.getMonitorService();
final List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();

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

@ -16,7 +16,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -48,8 +47,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCategoryReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfCategoryReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CategoryReport report = monitorService.createCategoryReportBuilder().buildReport();
@ -72,8 +70,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCategoryReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetCategoryReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -106,7 +103,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReport() throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -137,8 +134,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportNotInWorkingDays()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -165,8 +161,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
@ -200,8 +195,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -234,8 +228,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -265,8 +258,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
@ -299,8 +291,7 @@ class ProvideCategoryReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCategoryReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCategoryReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -16,7 +16,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -46,8 +45,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
ClassificationReport report = monitorService.createClassificationReportBuilder().buildReport();
@ -74,8 +72,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetClassificationReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetClassificationReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnsHeaders();
@ -117,8 +114,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -155,8 +151,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportNotInWorkingDays()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -192,8 +187,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
@ -233,8 +227,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -273,8 +266,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -304,8 +296,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
@ -344,8 +335,7 @@ class ProvideClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfClassificationReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfClassificationReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -15,7 +15,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -45,8 +44,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom1()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom1() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomFieldValueReport report =
@ -71,8 +69,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom2()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfCustomFieldValueReportForCustom2() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomFieldValueReport report =
@ -96,8 +93,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetCustomFieldValueReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetCustomFieldValueReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
CustomField customField = CustomField.CUSTOM_1;
@ -128,8 +124,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReport()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -160,8 +155,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportNotInWorkingDays()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -191,8 +185,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
@ -226,8 +219,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -260,8 +252,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -294,8 +285,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
@ -328,8 +318,7 @@ class ProvideCustomFieldValueReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfCustomFieldValueReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfCustomFieldValueReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -15,7 +15,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -48,8 +47,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfDetailedClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfDetailedClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
DetailedClassificationReport report =
@ -101,8 +99,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetDetailedClassificationReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -134,8 +131,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -199,8 +195,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
@ -264,8 +259,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -328,8 +322,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportNotInWorkingDays()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -392,8 +385,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -435,8 +427,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
@ -499,8 +490,7 @@ class ProvideDetailedClassificationReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfDetailedClassificationReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfDetailedClassificationReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();

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

@ -2,19 +2,19 @@ package acceptance.report;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -25,8 +25,6 @@ import pro.taskana.monitor.api.reports.item.TaskQueryItem;
import pro.taskana.monitor.api.reports.row.Row;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
/** Acceptance test for all "task status report" scenarios. */
@ExtendWith(JaasExtension.class)
@ -35,29 +33,42 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
private static final Logger LOGGER =
LoggerFactory.getLogger(ProvideWorkbasketReportAccTest.class);
MonitorService monitorService = taskanaEngine.getMonitorService();
@BeforeEach
public void reset() throws Exception {
void reset() throws Exception {
resetDb();
}
@Test
void testRoleCheck() {
MonitorService monitorService = taskanaEngine.getMonitorService();
ThrowingCallable call =
() -> {
monitorService.createTaskStatusReportBuilder().buildReport();
};
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
void should_ThrowException_IfUserIsNotAuthorized() {
assertThatThrownBy(() -> monitorService.createTaskStatusReportBuilder().buildReport())
.isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "unknown")
@WithAccessId(user = "user-1-1")
@WithAccessId(user = "businessadmin")
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ThrowException_IfUserIsNotAdminOrMonitor() {
assertThatThrownBy(() -> monitorService.createTaskStatusReportBuilder().buildReport())
.isInstanceOf(NotAuthorizedException.class);
}
@WithAccessId(user = "admin")
@WithAccessId(user = "monitor")
@TestTemplate
void should_BuildReport_IfUserIsAdminOrMonitor() {
assertThatCode(() -> monitorService.createTaskStatusReportBuilder().buildReport())
.doesNotThrowAnyException();
}
@WithAccessId(user = "monitor")
@Test
void testCompleteTaskStatusReport() throws NotAuthorizedException, InvalidArgumentException {
// given
MonitorService monitorService = taskanaEngine.getMonitorService();
// when
void testCompleteTaskStatusReport() throws Exception {
TaskStatusReport report = monitorService.createTaskStatusReportBuilder().buildReport();
// then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
@ -81,27 +92,15 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
assertThat(sumRow.getTotalValue()).isEqualTo(50);
}
@WithAccessId(user = "admin")
@Test
void testCompleteTaskStatusReportAsAdmin()
throws NotAuthorizedException, InvalidArgumentException {
MonitorService monitorService = taskanaEngine.getMonitorService();
monitorService.createTaskStatusReportBuilder().buildReport();
}
@WithAccessId(user = "monitor")
@Test
void testCompleteTaskStatusReportWithDomainFilter()
throws NotAuthorizedException, InvalidArgumentException {
// given
MonitorService monitorService = taskanaEngine.getMonitorService();
// when
void testCompleteTaskStatusReportWithDomainFilter() throws Exception {
TaskStatusReport report =
monitorService
.createTaskStatusReportBuilder()
.domainIn(asList("DOMAIN_C", "DOMAIN_A"))
.buildReport();
// then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
@ -123,17 +122,13 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testCompleteTaskStatusReportWithStateFilter()
throws NotAuthorizedException, InvalidArgumentException {
// given
MonitorService monitorService = taskanaEngine.getMonitorService();
// when
void testCompleteTaskStatusReportWithStateFilter() throws Exception {
TaskStatusReport report =
monitorService
.createTaskStatusReportBuilder()
.stateIn(Collections.singletonList(TaskState.READY))
.buildReport();
// then
if (LOGGER.isDebugEnabled()) {
LOGGER.debug(reportToString(report));
}
@ -159,17 +154,13 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor", groups = "admin")
@Test
void testCompleteTaskStatusReportWithStates()
throws NotAuthorizedException, InvalidArgumentException, InvalidStateException,
TaskNotFoundException {
void testCompleteTaskStatusReportWithStates() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
taskService.terminateTask("TKI:000000000000000000000000000000000010");
taskService.terminateTask("TKI:000000000000000000000000000000000011");
taskService.terminateTask("TKI:000000000000000000000000000000000012");
taskService.cancelTask("TKI:000000000000000000000000000000000013");
taskService.cancelTask("TKI:000000000000000000000000000000000014");
MonitorService monitorService = taskanaEngine.getMonitorService();
TaskStatusReport report =
monitorService
.createTaskStatusReportBuilder()
@ -181,8 +172,6 @@ class ProvideTaskStatusReportAccTest extends AbstractReportAccTest {
TaskState.CANCELLED,
TaskState.TERMINATED))
.buildReport();
// String rep = reportToString(report);
// System.out.println(rep);
int[] summaryNumbers = report.getSumRow().getCells();
assertThat(summaryNumbers.length).isEqualTo(5);
assertThat(summaryNumbers[3]).isEqualTo(2); // number of cancelled tasks

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

@ -16,7 +16,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -46,8 +45,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfWorkbasketReportBasedOnDueDate()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfTasksOfWorkbasketReportBasedOnDueDate() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
WorkbasketReport report = monitorService.createWorkbasketReportBuilder().buildReport();
@ -68,8 +66,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetWorkbasketReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetWorkbasketReportWithReportLineItemDefinitions() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();
@ -103,7 +100,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReport() throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReport() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -134,8 +131,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportNotInWorkingDays()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportNotInWorkingDays() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -165,8 +161,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithWorkbasketFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportWithWorkbasketFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> workbasketIds =
@ -194,8 +189,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithStateFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportWithStateFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TaskState> states = Collections.singletonList(TaskState.READY);
@ -228,8 +222,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithCategoryFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportWithCategoryFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> categories = Arrays.asList("AUTOMATIC", "MANUAL");
@ -262,8 +255,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithDomainFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportWithDomainFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<String> domains = Collections.singletonList("DOMAIN_A");
@ -296,8 +288,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportWithCustomFieldValueFilter()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportWithCustomFieldValueFilter() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
Map<CustomField, String> customAttributeFilter = new HashMap<>();
@ -331,8 +322,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testEachItemOfWorkbasketReportForSelectedClassifications()
throws InvalidArgumentException, NotAuthorizedException {
void testEachItemOfWorkbasketReportForSelectedClassifications() throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getShortListOfColumnHeaders();
@ -380,7 +370,7 @@ class ProvideWorkbasketReportAccTest extends AbstractReportAccTest {
@WithAccessId(user = "monitor")
@Test
void testGetTotalNumbersOfTasksOfWorkbasketReportBasedOnPlannedDateWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
throws Exception {
MonitorService monitorService = taskanaEngine.getMonitorService();
List<TimeIntervalColumnHeader> columnHeaders = getListOfColumnHeaders();

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

@ -32,8 +32,7 @@ class TaskEngineAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void should_RunAsAdminOnlyTemorarily_When_RunAsAdminMethodIsCalled()
throws NoSuchFieldException, IllegalAccessException {
void should_RunAsAdminOnlyTemorarily_When_RunAsAdminMethodIsCalled() throws Exception {
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isTrue();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
@ -55,8 +54,7 @@ class TaskEngineAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void should_ConfirmBusinessAdminRole_When_AccessIdIsBusinessAdmin()
throws NotAuthorizedException {
void should_ConfirmBusinessAdminRole_When_AccessIdIsBusinessAdmin() throws Exception {
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isTrue();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN);
@ -64,7 +62,7 @@ class TaskEngineAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = "taskadmin")
@Test
void should_ConfirmTaskAdminRole_When_AccessIdIsTaskAdmin() throws NotAuthorizedException {
void should_ConfirmTaskAdminRole_When_AccessIdIsTaskAdmin() throws Exception {
assertThat(taskanaEngine.isUserInRole(TaskanaRole.TASK_ADMIN)).isTrue();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isFalse();
taskanaEngine.checkRoleMembership(TaskanaRole.TASK_ADMIN);
@ -72,7 +70,7 @@ class TaskEngineAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = "admin")
@Test
void should_ConfirmAdminRole_When_AccessIdIsAdmin() throws NotAuthorizedException {
void should_ConfirmAdminRole_When_AccessIdIsAdmin() throws Exception {
assertThat(taskanaEngine.isUserInRole(TaskanaRole.BUSINESS_ADMIN)).isFalse();
assertThat(taskanaEngine.isUserInRole(TaskanaRole.ADMIN)).isTrue();
taskanaEngine.checkRoleMembership(TaskanaRole.ADMIN);

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

@ -9,7 +9,6 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -64,8 +63,7 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryWorkbasketByBusinessAdmin()
throws NotAuthorizedException, InvalidArgumentException {
void testQueryWorkbasketByBusinessAdmin() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();
@ -84,7 +82,7 @@ class WorkbasketQueryAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryWorkbasketByAdmin() throws NotAuthorizedException, InvalidArgumentException {
void testQueryWorkbasketByAdmin() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").list();

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

@ -14,24 +14,17 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
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.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
@ -39,9 +32,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateTaskWithDifferentCallbackStates()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
void testCreateTaskWithDifferentCallbackStates() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
TaskImpl createdTask = createTask(taskService, CallbackState.NONE);
@ -65,10 +56,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testDeletionOfTaskWithWrongCallbackStateIsBlocked()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testDeletionOfTaskWithWrongCallbackStateIsBlocked() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
final TaskImpl createdTask =
@ -112,10 +100,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testUpdateOfCallbackState()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testUpdateOfCallbackState() throws Exception {
TaskImpl createdTask1 =
createTask(taskanaEngine.getTaskService(), CallbackState.CALLBACK_PROCESSING_REQUIRED);
@ -178,9 +163,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testInvalidUpdateOfCallbackStateToNone()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
void testInvalidUpdateOfCallbackStateToNone() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -214,10 +197,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testInvalidUpdateOfCallbackStateToComplete()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, InvalidOwnerException,
InvalidStateException, TaskNotFoundException {
void testInvalidUpdateOfCallbackStateToComplete() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -254,10 +234,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testInvalidUpdateOfCallbackStateToClaimed()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testInvalidUpdateOfCallbackStateToClaimed() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -298,9 +275,7 @@ class CallbackStateAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testInvalidUpdateOfCallbackStateToRequired()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
void testInvalidUpdateOfCallbackStateToRequired() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -389,8 +364,7 @@ class CallbackStateAccTest extends AbstractAccTest {
}
private TaskImpl createTask(TaskService taskService, CallbackState callbackState)
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
newTask.setPrimaryObjRef(

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

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeEach;
@ -12,13 +11,11 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
@ -34,7 +31,7 @@ class CancelTaskAccTest extends AbstractAccTest {
}
@BeforeEach
public void setupIndividualTest() throws Exception {
void setupIndividualTest() throws Exception {
resetDb(false);
}
@ -48,8 +45,7 @@ class CancelTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCancelReadyTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testCancelReadyTask() throws Exception {
List<TaskSummary> taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list();
assertThat(taskSummaries).hasSize(47);
taskService.cancelTask(taskSummaries.get(0).getId());
@ -63,7 +59,7 @@ class CancelTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_CancelTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException, SQLException {
throws Exception {
resetDb(false);
Task tasktoCancel = taskService.getTask("TKI:000000000000000000000000000000000001");
@ -75,8 +71,7 @@ class CancelTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testCancelClaimedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void testCancelClaimedTask() throws Exception {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();

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

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.time.Instant;
import java.util.Arrays;
import java.util.Collections;
@ -14,7 +13,6 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
@ -26,11 +24,9 @@ import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
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.Task;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance tests for all claim and complete scenarios. */
@ExtendWith(JaasExtension.class)
@ -40,9 +36,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCompleteTask()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException {
void testCompleteTask() throws Exception {
assertThat(TASK_SERVICE.getTask("TKI:000000000000000000000000000000000001").getState())
.isEqualTo(TaskState.CLAIMED);
Task completedTask = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000001");
@ -56,8 +50,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ForceCompleteTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException, SQLException {
throws Exception {
resetDb(false);
assertThat(TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000").getState())
@ -71,9 +64,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCompleteTaskTwice()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException {
void testCompleteTaskTwice() throws Exception {
Task completedTask = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000002");
Task completedTask2 = TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000002");
assertThat(completedTask2).isEqualTo(completedTask);
@ -81,10 +72,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testForceCompleteAlreadyClaimed()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidOwnerException, InvalidStateException {
void testForceCompleteAlreadyClaimed() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setOwner("other");
@ -105,10 +93,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testForceCompleteNotClaimed()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidOwnerException, InvalidStateException {
void testForceCompleteNotClaimed() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setOwner("other");
@ -130,9 +115,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskIsNotFound() {
ThrowingCallable call =
() -> {
TASK_SERVICE.completeTask("TKI:0000000000000000000000000000000000xx");
};
() -> TASK_SERVICE.completeTask("TKI:0000000000000000000000000000000000xx");
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
}
@ -140,10 +123,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_UserIsNotAuthorizedOnTask() {
ThrowingCallable call =
call =
() -> {
TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000004");
};
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000004");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -151,10 +131,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskIsInStateReady() {
ThrowingCallable call =
call =
() -> {
TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000025");
};
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000025");
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@ -162,19 +139,13 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void should_ThrowException_When_TaskCallerIsNotTheOwner() {
ThrowingCallable call =
call =
() -> {
TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000026");
};
() -> TASK_SERVICE.completeTask("TKI:000000000000000000000000000000000026");
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-1")
@Test
void testClaimTaskWithDefaultFlag()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testClaimTaskWithDefaultFlag() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
@ -199,10 +170,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testForceClaimTaskFromOtherUser()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testForceClaimTaskFromOtherUser() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
@ -229,49 +197,35 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testClaimTaskNotExisting() {
ThrowingCallable call =
() -> {
TASK_SERVICE.claim("NOT_EXISTING");
};
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
assertThatThrownBy(() -> TASK_SERVICE.claim("NOT_EXISTING"))
.isInstanceOf(TaskNotFoundException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void testClaimTaskWithInvalidState() {
ThrowingCallable call =
() -> {
TASK_SERVICE.forceClaim("TKI:000000000000000000000000000000000036");
};
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
assertThatThrownBy(() -> TASK_SERVICE.forceClaim("TKI:000000000000000000000000000000000036"))
.isInstanceOf(InvalidStateException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void testClaimTaskWithInvalidOwner() {
ThrowingCallable call =
() -> {
TASK_SERVICE.claim("TKI:000000000000000000000000000000000035");
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
assertThatThrownBy(() -> TASK_SERVICE.claim("TKI:000000000000000000000000000000000035"))
.isInstanceOf(InvalidOwnerException.class);
}
@WithAccessId(user = "user-1-2")
@Test
void testCancelClaimForcedWithInvalidState() {
ThrowingCallable call =
() -> {
TASK_SERVICE.forceCancelClaim("TKI:000000000000000000000000000000000036");
};
() -> TASK_SERVICE.forceCancelClaim("TKI:000000000000000000000000000000000036");
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
}
@WithAccessId(user = "user-1-1")
@Test
void testCancelClaimDefaultFlag()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void testCancelClaimDefaultFlag() throws Exception {
Task newTask = TASK_SERVICE.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
@ -289,9 +243,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testForceCancelClaimSuccessfull()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException, InterruptedException {
void testForceCancelClaimSuccessfull() throws Exception {
Task taskBefore = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000043");
assertThat(taskBefore).isNotNull();
@ -312,11 +264,8 @@ class CompleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testCancelClaimWithInvalidOwner() {
ThrowingCallable call =
() -> {
TASK_SERVICE.cancelClaim("TKI:000000000000000000000000000000000035");
};
assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
assertThatThrownBy(() -> TASK_SERVICE.cancelClaim("TKI:000000000000000000000000000000000035"))
.isInstanceOf(InvalidOwnerException.class);
}
@Test

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

@ -15,7 +15,6 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineProxyForTest;
@ -24,9 +23,7 @@ import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
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.ObjectReference;
@ -34,7 +31,6 @@ import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.AttachmentMapper;
import pro.taskana.task.internal.TaskTestMapper;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.exceptions.WorkbasketInUseException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
@ -61,9 +57,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateSimpleManualTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void testCreateSimpleManualTask() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -96,9 +90,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_createTask_When_ObjectReferenceSystemAndSystemInstanceIsNull()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void should_createTask_When_ObjectReferenceSystemAndSystemInstanceIsNull() throws Exception {
String currentUser = CurrentUserContext.getUserid();
@ -118,8 +110,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_CreateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
NotAuthorizedException, ClassificationNotFoundException {
throws Exception {
String currentUser = CurrentUserContext.getUserid();
@ -137,9 +128,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testIdempotencyOfTaskCreation()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void testIdempotencyOfTaskCreation() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setExternalId("MyExternalId");
@ -179,10 +168,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateSimpleTaskWithCustomAttributes()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
void testCreateSimpleTaskWithCustomAttributes() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -247,10 +233,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateExternalTaskWithAttachment()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
void testCreateExternalTaskWithAttachment() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
@ -333,9 +316,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateExternalTaskWithMultipleAttachments()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void testCreateExternalTaskWithMultipleAttachments() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
@ -385,9 +366,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testPrioDurationOfTaskFromAttachmentsAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void testPrioDurationOfTaskFromAttachmentsAtCreate() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("L12010"); // prio 8, SL P7D
@ -444,7 +423,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testThrowsExceptionIfAttachmentIsInvalid() throws ClassificationNotFoundException {
void testThrowsExceptionIfAttachmentIsInvalid() throws Exception {
Consumer<Attachment> testCreateTask =
invalidAttachment -> {
@ -499,9 +478,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testUseCustomNameIfSetForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void testUseCustomNameIfSetForNewTask() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -517,9 +494,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testUseClassificationMetadataFromCorrectDomainForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void testUseClassificationMetadataFromCorrectDomainForNewTask() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -587,9 +562,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testSetDomainFromWorkbasket()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void testSetDomainFromWorkbasket() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -609,9 +582,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreatedTaskObjectEqualsReadTaskObject()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void testCreatedTaskObjectEqualsReadTaskObject() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -643,9 +614,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateSimpleTaskWithCallbackInfo()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
void testCreateSimpleTaskWithCallbackInfo() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -690,7 +659,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testCreateTaskAlreadyExisting() throws NotAuthorizedException, TaskNotFoundException {
void testCreateTaskAlreadyExisting() throws Exception {
Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -710,10 +679,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCreateTaskWithWorkbasketMarkedForDeletion()
throws NotAuthorizedException, InvalidStateException, TaskNotFoundException,
TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
ClassificationNotFoundException, WorkbasketInUseException {
void testCreateTaskWithWorkbasketMarkedForDeletion() throws Exception {
String wbId = "WBI:100000000000000000000000000000000008";
Task taskToPreventWorkbasketDeletion = taskService.newTask(wbId);

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

@ -8,8 +8,6 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
@ -17,7 +15,7 @@ import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskComment;
@ExtendWith(JaasExtension.class)
public class CreateTaskCommentAccTest extends AbstractAccTest {
class CreateTaskCommentAccTest extends AbstractAccTest {
CreateTaskCommentAccTest() {
super();
@ -25,8 +23,7 @@ public class CreateTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_CreateTaskComment_For_TaskComment()
throws TaskNotFoundException, NotAuthorizedException, InvalidArgumentException {
void should_CreateTaskComment_For_TaskComment() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();

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

@ -13,7 +13,6 @@ import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
@ -67,8 +66,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testDeleteSingleTask()
throws TaskNotFoundException, InvalidStateException, NotAuthorizedException {
void testDeleteSingleTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000036");
@ -99,8 +97,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testThrowsExceptionIfTaskIsNotCompleted()
throws TaskNotFoundException, NotAuthorizedException {
void testThrowsExceptionIfTaskIsNotCompleted() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000029");
@ -113,8 +110,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testForceDeleteTaskIfNotCompleted()
throws TaskNotFoundException, InvalidStateException, NotAuthorizedException {
void testForceDeleteTaskIfNotCompleted() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
@ -137,7 +133,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testBulkDeleteTask() throws InvalidArgumentException, NotAuthorizedException {
void testBulkDeleteTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
ArrayList<String> taskIdList = new ArrayList<>();
@ -156,8 +152,7 @@ class DeleteTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testBulkDeleteTasksWithException()
throws TaskNotFoundException, InvalidArgumentException, NotAuthorizedException {
void testBulkDeleteTasksWithException() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
ArrayList<String> taskIdList = new ArrayList<>();

20
lib/taskana-core/src/test/java/acceptance/task/DeleteTaskCommentAccTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.List;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
@ -17,11 +16,10 @@ import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskComment;
@ExtendWith(JaasExtension.class)
public class DeleteTaskCommentAccTest extends AbstractAccTest {
class DeleteTaskCommentAccTest extends AbstractAccTest {
DeleteTaskCommentAccTest() {
super();
@ -29,9 +27,7 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_DeleteTaskComment_For_TaskCommentId()
throws TaskCommentNotFoundException, NotAuthorizedException, TaskNotFoundException,
InvalidArgumentException {
void should_DeleteTaskComment_For_TaskCommentId() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -49,8 +45,7 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2", groups = "user-1-1") // to read comments
@Test
void should_FailToDeleteTaskComment_When_UserHasNoAuthorization()
throws NotAuthorizedException, TaskNotFoundException {
void should_FailToDeleteTaskComment_When_UserHasNoAuthorization() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -73,8 +68,7 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_DeleteTaskComment_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, TaskNotFoundException, TaskCommentNotFoundException,
InvalidArgumentException, SQLException {
throws Exception {
resetDb(false);
@ -94,8 +88,7 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_FailToDeleteTaskComment_When_TaskCommentIdIsInvalid()
throws NotAuthorizedException, TaskNotFoundException {
void should_FailToDeleteTaskComment_When_TaskCommentIdIsInvalid() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -117,8 +110,7 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_FailToDeleteTaskComment_When_TaskCommentIsNotExisting()
throws NotAuthorizedException, TaskNotFoundException {
void should_FailToDeleteTaskComment_When_TaskCommentIsNotExisting() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();

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

@ -10,7 +10,6 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -29,8 +28,7 @@ class GetTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTask_When_RequestingTaskByTaskId()
throws TaskNotFoundException, NotAuthorizedException, InvalidArgumentException {
void should_ReturnTask_When_RequestingTaskByTaskId() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -111,7 +109,7 @@ class GetTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ReturnTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, TaskNotFoundException {
throws Exception {
TaskService taskService = taskanaEngine.getTaskService();

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

@ -9,25 +9,19 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskComment;
@ExtendWith(JaasExtension.class)
public class GetTaskCommentAccTest extends AbstractAccTest {
GetTaskCommentAccTest() {
super();
}
class GetTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTaskComments_For_TaskId() throws NotAuthorizedException, TaskNotFoundException {
void should_ReturnTaskComments_For_TaskId() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -39,8 +33,7 @@ public class GetTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_ReturnEmptyList_When_TaskCommentsDontExist()
throws NotAuthorizedException, TaskNotFoundException {
void should_ReturnEmptyList_When_TaskCommentsDontExist() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -62,9 +55,7 @@ public class GetTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTaskComment_For_TaskCommentId()
throws TaskCommentNotFoundException, NotAuthorizedException, TaskNotFoundException,
InvalidArgumentException {
void should_ReturnTaskComment_For_TaskCommentId() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();

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

@ -9,12 +9,9 @@ import java.util.stream.Collectors;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
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;
@ -69,7 +66,7 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ConfirmIfAttachmentSummariesAreCorrect_When_UsingTaskQueryAndGetTaskById()
throws TaskNotFoundException, NotAuthorizedException {
throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
// find Task with ID TKI:00...00
List<TaskSummary> tasks =
@ -92,8 +89,7 @@ class QueryTaskWithAttachmentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ConfirmIfAttachmentSummariesAreCorrect()
throws InvalidArgumentException, TaskNotFoundException, NotAuthorizedException {
void should_ConfirmIfAttachmentSummariesAreCorrect() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
// find Task with ID TKI:00...00
List<TaskSummary> tasks =

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

@ -14,7 +14,6 @@ import static pro.taskana.task.api.TaskQueryColumnName.OWNER;
import static pro.taskana.task.api.TaskQueryColumnName.STATE;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
@ -26,7 +25,6 @@ import java.util.stream.Stream;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.assertj.core.api.SoftAssertions;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest;
@ -34,13 +32,10 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.extension.ExtendWith;
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;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineProxyForTest;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -48,10 +43,6 @@ import pro.taskana.common.internal.util.Triplet;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskQueryColumnName;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
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.ObjectReference;
@ -59,7 +50,6 @@ import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.TaskTestMapper;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
/** Acceptance test for all "query tasks with sorting" scenarios. */
@ -74,7 +64,7 @@ class QueryTasksAccTest extends AbstractAccTest {
}
@BeforeEach
void before() throws SQLException {
void before() throws Exception {
// required if single tests modify database
// TODO split test class into readOnly & modifying tests to improve performance
resetDb(false);
@ -221,10 +211,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentInSummary()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void testQueryForAttachmentInSummary() throws Exception {
Attachment attachment =
createAttachment(
@ -305,7 +292,7 @@ class QueryTasksAccTest extends AbstractAccTest {
}
void testQueryForCustomX(String customValue, String[] searchArguments, int expectedResult)
throws InvalidArgumentException {
throws Exception {
List<TaskSummary> results =
taskService.createTaskQuery().customAttributeLike(customValue, searchArguments).list();
assertThat(results).hasSize(expectedResult);
@ -321,39 +308,24 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryForCustom7WithExceptionInLike() {
ThrowingCallable call =
() -> {
List<TaskSummary> results = taskService.createTaskQuery().customAttributeLike("7").list();
assertThat(results).isEmpty();
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeLike("7").list())
.isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(user = "admin")
@Test
void testQueryForCustom7WithExceptionInIn() throws InvalidArgumentException {
void testQueryForCustom7WithExceptionInIn() throws Exception {
List<TaskSummary> results =
taskService.createTaskQuery().customAttributeLike("7", "fsdhfshk%").list();
assertThat(results).isEmpty();
String[] ids =
results.stream().map(wrap(t -> t.getCustomAttribute("7"))).toArray(String[]::new);
ThrowingCallable call =
() -> {
List<TaskSummary> result2 =
taskService.createTaskQuery().customAttributeIn("7", ids).list();
assertThat(result2).isEmpty();
};
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
assertThatThrownBy(() -> taskService.createTaskQuery().customAttributeIn("7").list())
.isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(user = "admin")
@Test
void testQueryForCustom7WithException() throws InvalidArgumentException {
void testQueryForCustom7WithException() throws Exception {
List<TaskSummary> results = taskService.createTaskQuery().customAttributeLike("7", "%").list();
assertThat(results).hasSize(2);
@ -366,11 +338,7 @@ class QueryTasksAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryTaskByCustomAttributes()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, NoSuchFieldException,
IllegalAccessException {
void testQueryTaskByCustomAttributes() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
@ -640,7 +608,7 @@ class QueryTasksAccTest extends AbstractAccTest {
}
void testQueryForOrderByCustomX(String customValue, SortDirection sortDirection)
throws InvalidArgumentException {
throws Exception {
List<TaskSummary> results =
taskService.createTaskQuery().orderByCustomAttribute(customValue, sortDirection).list();

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

@ -7,7 +7,6 @@ import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
@ -23,7 +22,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryTasksByExcactValueOfObjectReference() throws SystemException {
void testQueryTasksByExcactValueOfObjectReference() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceValueIn("11223344", "22334455").list();
@ -32,7 +31,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryTasksByExcactValueAndTypeOfObjectReference() throws SystemException {
void testQueryTasksByExcactValueAndTypeOfObjectReference() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results =
taskService
@ -45,7 +44,7 @@ class QueryTasksByObjectReferenceAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryTasksByValueLikeOfObjectReference() throws SystemException {
void testQueryTasksByValueLikeOfObjectReference() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results =
taskService.createTaskQuery().primaryObjectReferenceValueLike("%567%").list();

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

@ -17,7 +17,7 @@ import pro.taskana.task.api.WildcardSearchField;
import pro.taskana.task.api.models.TaskSummary;
@ExtendWith(JaasExtension.class)
public class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test

6
lib/taskana-core/src/test/java/acceptance/task/SelectAndClaimTaskAccTest.java
View File

@ -50,14 +50,16 @@ class SelectAndClaimTaskAccTest extends AbstractAccTest {
threads[i].join();
}
assertThat(selectedAndClaimedTasks).extracting(Task::getId)
assertThat(selectedAndClaimedTasks)
.extracting(Task::getId)
.containsExactlyInAnyOrder(
"TKI:000000000000000000000000000000000003",
"TKI:000000000000000000000000000000000004",
"TKI:000000000000000000000000000000000005",
"TKI:000000000000000000000000000000000006");
assertThat(selectedAndClaimedTasks).extracting(Task::getOwner)
assertThat(selectedAndClaimedTasks)
.extracting(Task::getOwner)
.containsExactlyInAnyOrder("admin", "taskadmin", "teamlead-1", "teamlead-2");
}

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

@ -3,7 +3,6 @@ package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
@ -22,14 +21,12 @@ import pro.taskana.task.api.models.TaskSummary;
/** Acceptance test for planned and prio of all tasks. */
@ExtendWith(JaasExtension.class)
@SuppressWarnings({"checkstyle:LineLength"})
public class ServiceLevelOfAllTasksAccTest extends AbstractAccTest {
TaskService taskService;
class ServiceLevelOfAllTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test
void testSetPlannedPropertyOnAllTasks() throws SQLException {
taskService = taskanaEngine.getTaskService();
void testSetPlannedPropertyOnAllTasks() throws Exception {
Instant planned = getInstant("2020-05-03T07:00:00");
List<TaskSummary> allTasks = taskService.createTaskQuery().list();
// Now update each task with updateTask() and new planned

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

@ -20,28 +20,21 @@ 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.Classification;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.WorkingDaysToDaysConverter;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
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.Task;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
@SuppressWarnings({"checkstyle:LineLength"})
public class ServiceLevelPriorityAccTest extends AbstractAccTest {
class ServiceLevelPriorityAccTest extends AbstractAccTest {
private final TaskService taskService;
private final ClassificationService classificationService;
@ -57,9 +50,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_CalculatePlannedDateAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void should_CalculatePlannedDateAtCreate() throws Exception {
// P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
@ -87,9 +78,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_calculateDueDateAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void should_calculateDueDateAtCreate() throws Exception {
// P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
@ -118,8 +107,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_NotThrowException_When_DueAndPlannedAreConsistent()
throws ClassificationNotFoundException {
void should_NotThrowException_When_DueAndPlannedAreConsistent() throws Exception {
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
long duration = Duration.parse(classification.getServiceLevel()).toDays();
@ -198,8 +186,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-b-2")
@Test
void should_SetPlanned_When_SetPlannedRequestContainsDuplicateTaskIds()
throws NotAuthorizedException, TaskNotFoundException {
void should_SetPlanned_When_SetPlannedRequestContainsDuplicateTaskIds() throws Exception {
// This test works with the following tasks (w/o attachments) and classifications
//
@ -235,8 +222,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-b-2")
@Test
void should_SetPlanned_When_RequestContainsDuplicatesAndNotExistingTaskIds()
throws NotAuthorizedException, TaskNotFoundException {
void should_SetPlanned_When_RequestContainsDuplicatesAndNotExistingTaskIds() throws Exception {
String tkId1 = "TKI:000000000000000000000000000000000058";
String tkId2 = "TKI:000000000000000000000000000047110059";
@ -359,8 +345,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_SetPlannedPropertyOfTasks_When_RequestedByAdminUser()
throws NotAuthorizedException, TaskNotFoundException {
void should_SetPlannedPropertyOfTasks_When_RequestedByAdminUser() throws Exception {
String tkId1 = "TKI:000000000000000000000000000000000008";
String tkId2 = "TKI:000000000000000000000000000000000009";
String tkId3 = "TKI:000000000000000000000000000000000008";
@ -402,8 +387,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
// +-----------------------------------------+------------------------------------------+------+
@WithAccessId(user = "admin")
@Test
void should_SetPlannedPropertyWithBulkUpdate_When_RequestContainsASingleTask()
throws NotAuthorizedException, TaskNotFoundException {
void should_SetPlannedPropertyWithBulkUpdate_When_RequestContainsASingleTask() throws Exception {
String taskId = "TKI:000000000000000000000000000000000002";
Instant planned = getInstant("2020-05-03T07:00:00");
// test bulk operation setPlanned...
@ -417,10 +401,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_SetPlannedPropertyOnSingle_When_UpdateTaskWasCalled()
throws NotAuthorizedException, TaskNotFoundException, InvalidArgumentException,
ConcurrencyException, InvalidStateException, ClassificationNotFoundException,
AttachmentPersistenceException {
void should_SetPlannedPropertyOnSingle_When_UpdateTaskWasCalled() throws Exception {
String taskId = "TKI:000000000000000000000000000000000002";
Task task = taskService.getTask(taskId);
// test update of planned date via updateTask()
@ -432,10 +413,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_SetPlanned_When_OnlyDueWasChanged()
throws NotAuthorizedException, TaskNotFoundException, InvalidArgumentException,
ConcurrencyException, InvalidStateException, ClassificationNotFoundException,
AttachmentPersistenceException {
void should_SetPlanned_When_OnlyDueWasChanged() throws Exception {
String taskId = "TKI:000000000000000000000000000000000002"; // P1D
Instant planned = getInstant("2020-05-03T07:00:00");
Task task = taskService.getTask(taskId);
@ -480,10 +458,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void should_SetDue_When_TaskUpdateIsCalled()
throws NotAuthorizedException, TaskNotFoundException, InvalidArgumentException,
ConcurrencyException, InvalidStateException, ClassificationNotFoundException,
AttachmentPersistenceException {
void should_SetDue_When_TaskUpdateIsCalled() throws Exception {
String taskId = "TKI:000000000000000000000000000000000002";
final Instant planned = getInstant("2020-05-03T07:00:00"); // Sunday
Task task = taskService.getTask(taskId);
@ -513,10 +488,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_UpdateTaskPlannedOrDue_When_PlannedOrDueAreWeekendDays()
throws NotAuthorizedException, TaskNotFoundException, ClassificationNotFoundException,
InvalidArgumentException, InvalidStateException, ConcurrencyException,
AttachmentPersistenceException {
void should_UpdateTaskPlannedOrDue_When_PlannedOrDueAreWeekendDays() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000030"); // SL=P13D
task.setPlanned(getInstant("2020-03-21T07:00:00")); // planned = saturday
task = taskService.updateTask(task);
@ -545,9 +517,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdateTaskPlannedOrDue_When_PlannedOrDueAreOnWeekends_ServiceLevel_P0D()
throws NotAuthorizedException, TaskNotFoundException, ClassificationNotFoundException,
InvalidArgumentException, InvalidStateException, ConcurrencyException,
AttachmentPersistenceException {
throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000066"); // P0D
// nothing changed
@ -617,10 +587,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_notThrowServiceLevelViolation_IfWeekendOrHolidaysBetweenDates()
throws NotAuthorizedException, TaskNotFoundException, ClassificationNotFoundException,
InvalidArgumentException, InvalidStateException, ConcurrencyException,
AttachmentPersistenceException {
void should_notThrowServiceLevelViolation_IfWeekendOrHolidaysBetweenDates() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000002"); // P1D
// SLA is broken but only with holidays in between

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

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@ -15,10 +14,7 @@ import org.assertj.core.api.Condition;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.TaskanaEngineProxyForTest;
@ -26,8 +22,6 @@ import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Task;
@ -35,14 +29,11 @@ import pro.taskana.task.api.models.TaskSummary;
/** Acceptance test for all "set owner" scenarios. */
@ExtendWith(JaasExtension.class)
public class SetOwnerAccTest extends AbstractAccTest {
class SetOwnerAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testSetOwnerAndSubsequentClaimSucceeds()
throws TaskNotFoundException, NotAuthorizedException, InvalidStateException,
InvalidOwnerException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, AttachmentPersistenceException {
void testSetOwnerAndSubsequentClaimSucceeds() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
String taskReadyId = "TKI:000000000000000000000000000000000025";
@ -75,7 +66,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testSetOwnerOfClaimedTaskFails() throws TaskNotFoundException, NotAuthorizedException {
void testSetOwnerOfClaimedTaskFails() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
String taskClaimedId = "TKI:000000000000000000000000000000000026";
@ -163,8 +154,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testSetOwnerWithAllTasksAndVariousExceptions()
throws NoSuchFieldException, IllegalAccessException, SQLException {
void testSetOwnerWithAllTasksAndVariousExceptions() throws Exception {
resetDb(false);
List<TaskSummary> allTaskSummaries =
new TaskanaEngineProxyForTest(taskanaEngine)
@ -192,7 +182,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin() throws SQLException {
void testSetOwnerWithAllTasksAndVariousExceptionsAsAdmin() throws Exception {
resetDb(false);
List<TaskSummary> allTaskSummaries = taskanaEngine.getTaskService().createTaskQuery().list();
List<String> allTaskIds =
@ -207,10 +197,7 @@ public class SetOwnerAccTest extends AbstractAccTest {
.hasOnlyElementsOfType(InvalidStateException.class);
}
private Task setOwner(String taskReadyId, String anyUserName)
throws TaskNotFoundException, NotAuthorizedException, ClassificationNotFoundException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
private Task setOwner(String taskReadyId, String anyUserName) throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask(taskReadyId);
task.setOwner(anyUserName);

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

@ -18,7 +18,6 @@ import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskSummary;
/** Acceptance tests for "terminate task" scenarios. */
@ -27,7 +26,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
private static TaskService taskService;
@BeforeEach
public void setupIndividualTest() throws Exception {
void setupIndividualTest() throws Exception {
resetDb(false);
}
@ -47,8 +46,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_TerminateTask_When_TaskStateIsReady()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void should_TerminateTask_When_TaskStateIsReady() throws Exception {
List<TaskSummary> taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list();
assertThat(taskSummaries).hasSize(47);
taskService.terminateTask(taskSummaries.get(0).getId());
@ -61,8 +59,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_TerminateTask_When_TaskStateIsClaimed()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
void should_TerminateTask_When_TaskStateIsClaimed() throws Exception {
List<TaskSummary> taskSummaries =
taskService.createTaskQuery().stateIn(TaskState.CLAIMED).list();
assertThat(taskSummaries.size()).isEqualTo(20);

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

@ -23,7 +23,6 @@ import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Task;
@ -40,9 +39,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_TransferTaskToWorkbasket_When_WorkbasketIdIsProvided()
throws NotAuthorizedException, WorkbasketNotFoundException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void should_TransferTaskToWorkbasket_When_WorkbasketIdIsProvided() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
@ -61,8 +58,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_TransferTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, WorkbasketNotFoundException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
@ -79,9 +75,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_TransferTaskToWorkbasket_When_WorkbasketKeyAndDomainIsProvided()
throws NotAuthorizedException, WorkbasketNotFoundException, TaskNotFoundException,
InvalidStateException, InvalidOwnerException {
void should_TransferTaskToWorkbasket_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
@ -98,9 +92,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void should_ChangeDomain_When_TransferingTaskToWorkbasketWithDifferentDomain()
throws NotAuthorizedException, WorkbasketNotFoundException, TaskNotFoundException,
InvalidStateException {
void should_ChangeDomain_When_TransferingTaskToWorkbasketWithDifferentDomain() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
String domain1 = task.getDomain();
@ -113,8 +105,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_UserHasNoTransferAuthorization()
throws NotAuthorizedException, TaskNotFoundException {
void should_ThrowException_When_UserHasNoTransferAuthorization() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
@ -127,9 +118,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_ThrowException_When_DestinationWorkbasketDoesNotExist()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void should_ThrowException_When_DestinationWorkbasketDoesNotExist() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
taskService.claim(task.getId());
@ -176,8 +165,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void should_ThrowException_When_TransferWithNoAppendAuthorization()
throws NotAuthorizedException, TaskNotFoundException {
void should_ThrowException_When_TransferWithNoAppendAuthorization() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
@ -196,8 +184,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1")
@Test
void should_ThrowException_When_TaskToTransferIsAlreadyCompleted()
throws NotAuthorizedException, TaskNotFoundException {
void should_ThrowException_When_TaskToTransferIsAlreadyCompleted() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
@ -210,9 +197,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_BulkTransferTasks_When_WorkbasketIdIsProvided()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
TaskNotFoundException {
void should_BulkTransferTasks_When_WorkbasketIdIsProvided() throws Exception {
final Instant before = Instant.now();
TaskService taskService = taskanaEngine.getTaskService();
ArrayList<String> taskIdList = new ArrayList<>();
@ -248,8 +233,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_BulkTransferOnlyValidTasks_When_SomeTasksToTransferCauseExceptions()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
TaskNotFoundException {
throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
final Workbasket wb =
taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
@ -375,9 +359,7 @@ class TransferTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
@Test
void should_BulkTransferTasks_When_WorkbasketKeyAndDomainIsProvided()
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidArgumentException,
TaskNotFoundException {
void should_BulkTransferTasks_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
final Instant before = Instant.now();
TaskService taskService = taskanaEngine.getTaskService();
List<String> taskIdList = new ArrayList<>();

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

@ -15,23 +15,17 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
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.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance test for all "update task" scenarios. */
@ExtendWith(JaasExtension.class)
@ -41,10 +35,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdatePrimaryObjectReferenceOfTask_When_Requested()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void should_UpdatePrimaryObjectReferenceOfTask_When_Requested() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Instant modifiedOriginal = task.getModified();
@ -70,9 +61,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdatePrimaryObjectReferenceOfTask_When_ObjectreferenceSystemAndSystemInstanceIsNull()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Instant modifiedOriginal = task.getModified();
@ -99,7 +88,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_MandatoryPrimaryObjectReferenceIsNotSetOrIncomplete()
throws NotAuthorizedException, TaskNotFoundException {
throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setPrimaryObjRef(null);
@ -126,10 +115,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_TaskHasAlreadyBeenUpdated()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException, InterruptedException {
void should_ThrowException_When_TaskHasAlreadyBeenUpdated() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Task task2 = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -148,7 +134,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_UpdateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, TaskNotFoundException {
throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setClassificationKey("T2100");
@ -176,8 +162,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_UpdateReadFlagOfTask_When_SetTaskReadIsCalled()
throws TaskNotFoundException, NotAuthorizedException {
void should_UpdateReadFlagOfTask_When_SetTaskReadIsCalled() throws Exception {
taskService.setTaskRead("TKI:000000000000000000000000000000000030", true);
Task updatedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
@ -197,10 +182,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdateTask_When_CustomPropertiesOfTaskWereChanged()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void should_UpdateTask_When_CustomPropertiesOfTaskWereChanged() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setCustomAttribute("1", "T2100");
Task updatedTask = taskService.updateTask(task);
@ -211,8 +193,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_ModificationOfWorkbasketKeyIsAttempted()
throws NotAuthorizedException, TaskNotFoundException {
void should_ThrowException_When_ModificationOfWorkbasketKeyIsAttempted() throws Exception {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
((TaskImpl) task).setWorkbasketKey("USER-2-2");
@ -224,7 +205,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdateNoTasks_When_UpdateTasksWithUnmatchedObjectReferenceWasCalled()
throws InvalidArgumentException {
throws Exception {
ObjectReference por = new ObjectReference();
por.setCompany("00");
por.setSystem("PASystem");
@ -243,8 +224,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1")
@Test
void should_UpdateTasks_When_MatchingPrimaryObjectReferenceWasChanged()
throws InvalidArgumentException, TaskNotFoundException, NotAuthorizedException {
void should_UpdateTasks_When_MatchingPrimaryObjectReferenceWasChanged() throws Exception {
ObjectReference por = new ObjectReference();
por.setCompany("00");
por.setSystem("PASystem");
@ -270,8 +250,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1")
@Test
void should_UpdateTaskCustomAttributes_When_UpdateTasksIsCalled()
throws InvalidArgumentException, TaskNotFoundException, NotAuthorizedException {
void should_UpdateTaskCustomAttributes_When_UpdateTasksIsCalled() throws Exception {
List<String> taskIds =
Arrays.asList(
"TKI:000000000000000000000000000000000008",
@ -297,10 +276,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_UpdateCallbackInfo_When_RequestedByApi()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
ConcurrencyException, AttachmentPersistenceException, InvalidStateException {
void should_UpdateCallbackInfo_When_RequestedByApi() throws Exception {
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
newTask.setClassificationKey("T2100");

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

@ -13,26 +13,18 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.AttachmentPersistenceException;
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;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/**
* Acceptance test for the usecase of adding/removing an attachment of a task and update the result
@ -47,10 +39,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@BeforeEach
@WithAccessId(user = "admin")
void setUp()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void setUp() throws Exception {
taskService = taskanaEngine.getTaskService();
task =
taskService.getTask(
@ -75,10 +64,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddNewAttachment()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void testAddNewAttachment() throws Exception {
final int attachmentCount = task.getAttachments().size();
assertThat(task.getPriority()).isEqualTo(1);
assertThat(task.getPlanned().plus(Duration.ofDays(1))).isEqualTo(task.getDue());
@ -95,10 +81,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddValidAttachmentTwice()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testAddValidAttachmentTwice() throws Exception {
task.getAttachments().clear();
task = taskService.updateTask(task);
task = taskService.getTask(task.getId());
@ -119,9 +102,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddNewAttachmentTwiceWithoutTaskanaMethodWillThrowAttachmentPersistenceException()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
throws Exception {
final int attachmentCount = 0;
task.getAttachments().clear();
task = taskService.updateTask(task);
@ -138,10 +119,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddExistingAttachmentAgainWillUpdateWhenNotEqual()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void testAddExistingAttachmentAgainWillUpdateWhenNotEqual() throws Exception {
// Add attachment before
task = taskService.getTask(task.getId());
final int attachmentCount = task.getAttachments().size();
@ -173,10 +151,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddExistingAttachmentAgainWillDoNothingWhenEqual()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void testAddExistingAttachmentAgainWillDoNothingWhenEqual() throws Exception {
// Add Attachment before
final int attachmentCount = task.getAttachments().size();
((AttachmentImpl) attachment).setId("TAI:0001");
@ -197,10 +172,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testAddAttachmentAsNullValueWillBeIgnored()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testAddAttachmentAsNullValueWillBeIgnored() throws Exception {
// Try to add a single NULL-Element
final int attachmentCount = task.getAttachments().size();
task.addAttachment(null);
@ -231,10 +203,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testRemoveAttachment()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testRemoveAttachment() throws Exception {
task.addAttachment(attachment);
task = taskService.updateTask(task);
assertThat(task.getPriority()).isEqualTo(99);
@ -253,10 +222,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testRemoveAttachmentWithNullAndNotAddedId()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testRemoveAttachmentWithNullAndNotAddedId() throws Exception {
task.addAttachment(attachment);
task = taskService.updateTask(task);
int attachmentCount = task.getAttachments().size();
@ -276,10 +242,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testUpdateAttachment()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
void testUpdateAttachment() throws Exception {
((TaskImpl) task).setAttachments(new ArrayList<>());
task = taskService.updateTask(task);
assertThat(task.getPriority()).isEqualTo(1);
@ -385,10 +348,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void replaceExistingAttachments()
throws TaskNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
InvalidArgumentException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
void replaceExistingAttachments() throws Exception {
// setup test
assertThat(task.getAttachments()).isEmpty();
task.addAttachment(attachment);
@ -446,9 +406,7 @@ class UpdateTaskAttachmentsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void testPrioDurationOfTaskFromAttachmentsAtUpdate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
void testPrioDurationOfTaskFromAttachmentsAtUpdate() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");

24
lib/taskana-core/src/test/java/acceptance/task/UpdateTaskCommentAccTest.java
View File

@ -10,28 +10,19 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskCommentNotFoundException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.TaskComment;
import pro.taskana.task.internal.models.TaskCommentImpl;
@ExtendWith(JaasExtension.class)
public class UpdateTaskCommentAccTest extends AbstractAccTest {
UpdateTaskCommentAccTest() {
super();
}
class UpdateTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void should_UpdateTaskComment_For_TaskComment()
throws TaskCommentNotFoundException, NotAuthorizedException, ConcurrencyException,
TaskNotFoundException, InvalidArgumentException {
void should_UpdateTaskComment_For_TaskComment() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -53,9 +44,7 @@ public class UpdateTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_FailToUpdateTaskComment_When_UserHasNoAuthorization()
throws TaskCommentNotFoundException, NotAuthorizedException, TaskNotFoundException,
InvalidArgumentException {
void should_FailToUpdateTaskComment_When_UserHasNoAuthorization() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -81,8 +70,7 @@ public class UpdateTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_FailToUpdateTaskComment_When_UserTriesToUpdateTaskByManipulatingOwner()
throws TaskCommentNotFoundException, NotAuthorizedException, TaskNotFoundException,
InvalidArgumentException {
throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
@ -101,9 +89,7 @@ public class UpdateTaskCommentAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@Test
void should_FailToUpdateTaskComment_When_TaskCommentWasModifiedConcurrently()
throws TaskCommentNotFoundException, NotAuthorizedException, TaskNotFoundException,
ConcurrencyException, InvalidArgumentException {
void should_FailToUpdateTaskComment_When_TaskCommentWasModifiedConcurrently() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();

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

@ -1,6 +1,7 @@
package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
@ -13,8 +14,6 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BulkOperationResults;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -31,9 +30,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testClaimTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testClaimTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000025");
@ -51,8 +48,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testThrowsExceptionIfTaskIsAlreadyClaimed()
throws NotAuthorizedException, TaskNotFoundException {
void testThrowsExceptionIfTaskIsAlreadyClaimed() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000026");
@ -65,19 +61,17 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testClaimAlreadyClaimedByCallerTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testClaimAlreadyClaimedByCallerTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
taskService.claim(task.getId());
assertThat(task.getState()).isSameAs(TaskState.CLAIMED);
assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
}
@WithAccessId(user = "user-1-2")
@Test
void testForceClaimTaskWhichIsAlreadyClaimedByAnotherUser()
throws NotAuthorizedException, TaskNotFoundException {
void testForceClaimTaskWhichIsAlreadyClaimedByAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000028");
@ -90,9 +84,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testCancelClaimTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testCancelClaimTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
@ -108,8 +100,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testThrowsExceptionIfCancelClaimOfTaskFromAnotherUser()
throws NotAuthorizedException, TaskNotFoundException {
void testThrowsExceptionIfCancelClaimOfTaskFromAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
@ -122,9 +113,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testForceCancelClaimOfTaskFromAnotherUser()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testForceCancelClaimOfTaskFromAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
@ -140,9 +129,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testCompleteTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testCompleteTask() throws Exception {
final Instant before = Instant.now().minus(Duration.ofSeconds(3L));
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000032");
@ -162,9 +149,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testForceCompleteUnclaimedTask()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testForceCompleteUnclaimedTask() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000033");
@ -181,8 +166,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testThrowsExceptionIfCompletingClaimedTaskOfAnotherUser()
throws NotAuthorizedException, TaskNotFoundException {
void testThrowsExceptionIfCompletingClaimedTaskOfAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000034");
@ -195,9 +179,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testForceCompleteClaimedTaskOfAnotherUser()
throws NotAuthorizedException, TaskNotFoundException, InvalidStateException,
InvalidOwnerException {
void testForceCompleteClaimedTaskOfAnotherUser() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000035");
@ -214,7 +196,7 @@ class WorkOnTaskAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testBulkDeleteTasksWithException() throws InvalidArgumentException, NotAuthorizedException {
void testBulkDeleteTasksWithException() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
String id1 = "TKI:000000000000000000000000000000000102";

20
lib/taskana-core/src/test/java/acceptance/taskrouting/TaskRoutingAccTest.java
View File

@ -7,16 +7,12 @@ import acceptance.AbstractAccTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
@ -24,9 +20,7 @@ class TaskRoutingAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCreateTaskWithoutWorkbasketAndVoidNewTaskMethod()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
void testCreateTaskWithoutWorkbasketAndVoidNewTaskMethod() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask();
@ -47,9 +41,7 @@ class TaskRoutingAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCreateTaskWithNullWorkbasket()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
void testCreateTaskWithNullWorkbasket() throws Exception {
TaskImpl createdTaskA = createTask("DOMAIN_A", "L12010");
assertThat("WBI:100000000000000000000000000000000001")
.isEqualTo(createdTaskA.getWorkbasketSummary().getId());
@ -62,7 +54,7 @@ class TaskRoutingAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCreateTaskWithNullRouting() throws InvalidArgumentException {
void testCreateTaskWithNullRouting() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask(null, "DOMAIN_A");
@ -76,7 +68,7 @@ class TaskRoutingAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testCreateTaskWithRoutingToMultipleWorkbaskets() throws InvalidArgumentException {
void testCreateTaskWithRoutingToMultipleWorkbaskets() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask(null, "DOMAIN_B");
@ -88,9 +80,7 @@ class TaskRoutingAccTest extends AbstractAccTest {
.isInstanceOf(InvalidArgumentException.class);
}
private TaskImpl createTask(String domain, String classificationKey)
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException {
private TaskImpl createTask(String domain, String classificationKey) throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask(null, domain);

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

@ -11,7 +11,6 @@ import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -20,7 +19,6 @@ import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
@ -34,10 +32,7 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateWorkbasket()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
InvalidWorkbasketException, WorkbasketAlreadyExistException, DomainNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testCreateWorkbasket() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
final int before = workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();
@ -170,9 +165,7 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testThrowsExceptionIfWorkbasketWithCaseInsensitiveSameKeyDomainIsCreated()
throws NotAuthorizedException, InvalidWorkbasketException, WorkbasketAlreadyExistException,
DomainNotFoundException {
void testThrowsExceptionIfWorkbasketWithCaseInsensitiveSameKeyDomainIsCreated() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.newWorkbasket("X123456", "DOMAIN_A");
@ -195,8 +188,7 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCreateWorkbasketWithAlreadyExistingKeyAndDomainAndEmptyIdUpdatesOlderWorkbasket()
throws DomainNotFoundException, InvalidWorkbasketException, NotAuthorizedException,
WorkbasketAlreadyExistException {
throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
// First create a new Workbasket.
Workbasket wb = workbasketService.newWorkbasket("newKey", "DOMAIN_A");
@ -218,10 +210,7 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testWorkbasketAccessItemSetName()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
InvalidWorkbasketException, WorkbasketAlreadyExistException, DomainNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testWorkbasketAccessItemSetName() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.createWorkbasketQuery().domainIn("DOMAIN_A").list().size();

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

@ -16,12 +16,8 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.InvalidOwnerException;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketInUseException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
@ -43,7 +39,7 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteWorkbasket() throws WorkbasketNotFoundException, NotAuthorizedException {
void testDeleteWorkbasket() throws Exception {
Workbasket wb = workbasketService.getWorkbasket("USER-2-2", "DOMAIN_A");
ThrowingCallable call =
@ -89,8 +85,7 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteWorkbasketAlsoAsDistributionTarget()
throws WorkbasketNotFoundException, NotAuthorizedException {
void testDeleteWorkbasketAlsoAsDistributionTarget() throws Exception {
Workbasket wb = workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
int distTargets =
workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000001").size();
@ -148,8 +143,7 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2", groups = "businessadmin")
@Test
void testDeleteWorkbasketWhichIsUsed()
throws WorkbasketNotFoundException, NotAuthorizedException {
void testDeleteWorkbasketWhichIsUsed() throws Exception {
Workbasket wb =
workbasketService.getWorkbasket("user-1-2", "DOMAIN_A"); // all rights, DOMAIN_A with Tasks
ThrowingCallable call =
@ -161,9 +155,7 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testCascadingDeleteOfAccessItems()
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidArgumentException,
WorkbasketAccessItemAlreadyExistException {
void testCascadingDeleteOfAccessItems() throws Exception {
Workbasket wb = workbasketService.getWorkbasket("WBI:100000000000000000000000000000000008");
String wbId = wb.getId();
// create 2 access Items
@ -195,10 +187,7 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testMarkWorkbasketForDeletion()
throws WorkbasketInUseException, NotAuthorizedException, WorkbasketNotFoundException,
InvalidArgumentException, InvalidOwnerException, InvalidStateException,
TaskNotFoundException {
void testMarkWorkbasketForDeletion() throws Exception {
final Workbasket wb =
workbasketService.getWorkbasket("WBI:100000000000000000000000000000000006");

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

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@ -33,8 +32,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testGetDistributionTargetsSucceedsById()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetDistributionTargetsSucceedsById() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketSummary workbasketSummary =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
@ -55,8 +53,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testGetDistributionTargetsSucceeds()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetDistributionTargetsSucceeds() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketSummary workbasketSummary =
workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
@ -78,8 +75,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDistributionTargetCallsWithNonExistingWorkbaskets()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testDistributionTargetCallsWithNonExistingWorkbaskets() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
String existingWb = "WBI:100000000000000000000000000000000001";
String nonExistingWb = "WBI:100000000000000000000000000000000xx1";
@ -112,7 +108,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ReturnDistributionTargets_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, WorkbasketNotFoundException {
throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
String existingWb = "WBI:100000000000000000000000000000000001";
@ -167,8 +163,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testAddAndRemoveDistributionTargets()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testAddAndRemoveDistributionTargets() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
@ -196,8 +191,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testAddAndRemoveDistributionTargetsOnWorkbasketWithoutReadPermission()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testAddAndRemoveDistributionTargetsOnWorkbasketWithoutReadPermission() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("GPK_B_KSC_2", "DOMAIN_B");
@ -220,8 +214,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void testAddDistributionTargetsFailsNotAuthorized()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testAddDistributionTargetsFailsNotAuthorized() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
@ -241,8 +234,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testSetDistributionTargets()
throws NotAuthorizedException, WorkbasketNotFoundException, SQLException {
void testSetDistributionTargets() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket sourceWorkbasket = workbasketService.getWorkbasket("GPK_KSC_1", "DOMAIN_A");
@ -269,7 +261,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testGetDistributionSourcesById() throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetDistributionSourcesById() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> distributionSources =
@ -289,8 +281,7 @@ class DistributionTargetsAccTest extends AbstractAccTest {
@WithAccessId(user = "teamlead-1")
@Test
void testGetDistributionSourcesByKeyDomain()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetDistributionSourcesByKeyDomain() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> distributionSources =

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

@ -30,7 +30,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testGetWorkbasketById() throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetWorkbasketById() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket =
@ -57,7 +57,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionButUserHasAdministrativeRole()
throws NotAuthorizedException, WorkbasketNotFoundException {
throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -73,7 +73,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, WorkbasketNotFoundException {
throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -85,8 +85,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testGetWorkbasketByKeyAndDomain()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetWorkbasketByKeyAndDomain() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("USER-1-2", "DOMAIN_A");
@ -132,7 +131,7 @@ class GetWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-2")
@Test
void testGetWorkbasketAsSummary() throws NotAuthorizedException, WorkbasketNotFoundException {
void testGetWorkbasketAsSummary() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketSummary workbasketSummary =

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

@ -13,8 +13,6 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.workbasket.api.WorkbasketPermission;
@ -295,7 +293,7 @@ class QueryWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "admin")
@Test
void testQueryWorkbasketByAdmin() throws NotAuthorizedException, InvalidArgumentException {
void testQueryWorkbasketByAdmin() throws Exception {
List<WorkbasketSummary> results =
workbasketService.createWorkbasketQuery().nameLike("%").orderByName(DESCENDING).list();
assertThat(results)

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

@ -31,7 +31,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryWorkbasketAccessItemValuesForColumnName() throws NotAuthorizedException {
void testQueryWorkbasketAccessItemValuesForColumnName() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<String> columnValueList =
workbasketService.createWorkbasketAccessItemQuery().listValues(WORKBASKET_ID, null);
@ -52,7 +52,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsForAccessIds() throws NotAuthorizedException {
void testQueryAccessItemsForAccessIds() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService
@ -79,7 +79,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsForAccessIdsOrderedDescending() throws NotAuthorizedException {
void testQueryAccessItemsForAccessIdsOrderedDescending() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketAccessItemQuery query =
workbasketService
@ -95,7 +95,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsForAccessIdsAndWorkbasketKey() throws NotAuthorizedException {
void testQueryAccessItemsForAccessIdsAndWorkbasketKey() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService
@ -110,7 +110,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsForAccessIdsWorkbasketKeyLike() throws NotAuthorizedException {
void testQueryAccessItemsForAccessIdsWorkbasketKeyLike() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService.createWorkbasketAccessItemQuery().workbasketKeyLike("GPK_KSC%").list();
@ -119,8 +119,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsForAccessIdsWorkbasketKeyLikeAndOrderAsc()
throws NotAuthorizedException {
void testQueryAccessItemsForAccessIdsWorkbasketKeyLikeAndOrderAsc() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService
@ -135,7 +134,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsByWorkbasketKey() throws NotAuthorizedException {
void testQueryAccessItemsByWorkbasketKey() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService
@ -147,7 +146,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAccessItemsByWorkbasketKeyOrderedDescending() throws NotAuthorizedException {
void testQueryAccessItemsByWorkbasketKeyOrderedDescending() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService
@ -162,7 +161,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryForIdIn() throws NotAuthorizedException {
void testQueryForIdIn() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
String[] expectedIds = {
"WAI:100000000000000000000000000000000001",
@ -176,7 +175,7 @@ class QueryWorkbasketAccessItemsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryForOrderById() throws NotAuthorizedException {
void testQueryForOrderById() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketAccessItem> results =
workbasketService

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

@ -12,9 +12,7 @@ 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.common.api.exceptions.SystemException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.workbasket.api.WorkbasketPermission;
@ -34,8 +32,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllTransferTargetsForUser()
throws NotAuthorizedException, InvalidArgumentException {
void testQueryAllTransferTargetsForUser() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
@ -63,8 +60,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllTransferTargetsForUserAndGroup()
throws NotAuthorizedException, InvalidArgumentException, SystemException {
void testQueryAllTransferTargetsForUserAndGroup() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
@ -76,8 +72,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllTransferTargetsForUserAndGroupSortedByNameAscending()
throws NotAuthorizedException, InvalidArgumentException, SystemException {
void testQueryAllTransferTargetsForUserAndGroupSortedByNameAscending() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
@ -91,8 +86,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllTransferTargetsForUserAndGroupSortedByNameDescending()
throws NotAuthorizedException, InvalidArgumentException, SystemException {
void testQueryAllTransferTargetsForUserAndGroupSortedByNameDescending() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
@ -107,8 +101,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testQueryAllTransferSourcesForUserAndGroup()
throws NotAuthorizedException, InvalidArgumentException, SystemException {
void testQueryAllTransferSourcesForUserAndGroup() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService
@ -124,7 +117,7 @@ class QueryWorkbasketByPermissionAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@Test
void testQueryAllTransferTargetsForUserAndGroupFromSubject() throws SystemException {
void testQueryAllTransferTargetsForUserAndGroupFromSubject() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
List<WorkbasketSummary> results =
workbasketService

12
lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAccTest.java
View File

@ -27,8 +27,7 @@ class UpdateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasket()
throws NotAuthorizedException, WorkbasketNotFoundException, ConcurrencyException {
void testUpdateWorkbasket() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("GPK_KSC", "DOMAIN_A");
@ -59,8 +58,7 @@ class UpdateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasketWithConcurrentModificationShouldThrowException()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testUpdateWorkbasketWithConcurrentModificationShouldThrowException() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -75,8 +73,7 @@ class UpdateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasketOfNonExistingWorkbasketShouldThrowException()
throws NotAuthorizedException, WorkbasketNotFoundException {
void testUpdateWorkbasketOfNonExistingWorkbasketShouldThrowException() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -93,8 +90,7 @@ class UpdateWorkbasketAccTest extends AbstractAccTest {
@WithAccessId(user = "user-1-1")
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin()
throws NotAuthorizedException, WorkbasketNotFoundException {
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
Workbasket workbasket = workbasketService.getWorkbasket("USER-1-1", "DOMAIN_A");

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

@ -15,11 +15,7 @@ import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
/** Acceptance test for all "update workbasket" scenarios that need a fresh database. */
@ExtendWith(JaasExtension.class)
public class UpdateWorkbasketAuthorizations2AccTest extends AbstractAccTest {
UpdateWorkbasketAuthorizations2AccTest() {
super();
}
class UpdateWorkbasketAuthorizations2AccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test

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

@ -1,6 +1,7 @@
package acceptance.workbasket;
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;
@ -12,20 +13,16 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.exceptions.NotAuthorizedToQueryWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
@ -60,9 +57,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasketAccessItemSucceeds()
throws InvalidArgumentException, NotAuthorizedException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testUpdateWorkbasketAccessItemSucceeds() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketAccessItem accessItem =
workbasketService.newWorkbasketAccessItem(
@ -94,9 +89,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testUpdateWorkbasketAccessItemRejected()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testUpdateWorkbasketAccessItemRejected() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
WorkbasketAccessItem accessItem =
workbasketService.newWorkbasketAccessItem(
@ -141,9 +134,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin", groups = GROUP_2_DN)
@Test
void testUpdatedAccessItemLeadsToNotAuthorizedException()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
ClassificationNotFoundException, TaskAlreadyExistException {
void testUpdatedAccessItemLeadsToNotAuthorizedException() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -291,7 +282,7 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteAccessItemsForAccessId() throws NotAuthorizedException {
void testDeleteAccessItemsForAccessId() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
final long accessIdCountBefore =
workbasketService.createWorkbasketAccessItemQuery().accessIdIn(GROUP_1_DN).count();
@ -305,11 +296,13 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@WithAccessId(user = "businessadmin")
@Test
void testDeleteAccessItemsForAccessIdWithUnusedValuesThrowingNoException()
throws NotAuthorizedException {
void testDeleteAccessItemsForAccessIdWithUnusedValuesThrowingNoException() throws Exception {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
workbasketService.deleteWorkbasketAccessItemsForAccessId("");
workbasketService.deleteWorkbasketAccessItemsForAccessId(null);
workbasketService.deleteWorkbasketAccessItemsForAccessId("123UNUSED456");
assertThatCode(() -> workbasketService.deleteWorkbasketAccessItemsForAccessId(""))
.doesNotThrowAnyException();
assertThatCode(() -> workbasketService.deleteWorkbasketAccessItemsForAccessId(null))
.doesNotThrowAnyException();
assertThatCode(() -> workbasketService.deleteWorkbasketAccessItemsForAccessId("123UNUSED456"))
.doesNotThrowAnyException();
}
}

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

@ -14,11 +14,12 @@ import com.openpojo.validation.test.impl.GetterTester;
import com.openpojo.validation.test.impl.SetterTester;
import com.tngtech.archunit.core.domain.JavaClass;
import com.tngtech.archunit.core.importer.ClassFileImporter;
import java.util.Collection;
import java.util.List;
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.BeforeAll;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
@ -26,75 +27,76 @@ import org.junit.jupiter.api.TestFactory;
/** check classes with a custom equals and hashcode implementation for correctness. */
class PojoTest {
private static List<Class<?>> pojoClasses;
@BeforeAll
static void setup() {
pojoClasses = getPojoClasses();
}
@Test
void testsThatPojoClassesAreFound() {
assertThat(getPojoClasses().count() > 0).isTrue();
assertThat(pojoClasses.stream().count() > 0).isTrue();
}
@TestFactory
Collection<DynamicTest> equalsContract() {
return getPojoClasses()
Stream<DynamicTest> equalsContract() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Check Hash and Equals for " + cl.getSimpleName(),
() -> verifyHashAndEquals(cl)))
.collect(Collectors.toList());
() -> verifyHashAndEquals(cl)));
}
@TestFactory
Collection<DynamicTest> validateGetters() {
return getPojoClasses()
Stream<DynamicTest> validateGetters() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Check Getter exist for " + cl.getSimpleName(),
() -> validateWithRules(cl, new GetterMustExistRule())))
.collect(Collectors.toList());
() -> validateWithRules(cl, new GetterMustExistRule())));
}
@TestFactory
Collection<DynamicTest> validateSetters() {
return getPojoClasses()
Stream<DynamicTest> validateSetters() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Check Setter for " + cl.getSimpleName(),
() -> validateWithRules(cl, new SetterMustExistRule())))
.collect(Collectors.toList());
() -> validateWithRules(cl, new SetterMustExistRule())));
}
@TestFactory
Collection<DynamicTest> validateGetAndSet() {
return getPojoClasses()
Stream<DynamicTest> validateGetAndSet() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Test set & get " + cl.getSimpleName(),
() -> validateWithTester(cl, new GetterTester(), new SetterTester())))
.collect(Collectors.toList());
() -> validateWithTester(cl, new GetterTester(), new SetterTester())));
}
@TestFactory
Collection<DynamicTest> validateNoStaticExceptFinalFields() {
return getPojoClasses()
Stream<DynamicTest> validateNoStaticExceptFinalFields() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Check static fields for " + cl.getSimpleName(),
() -> validateWithRules(cl, new NoStaticExceptFinalRule())))
.collect(Collectors.toList());
() -> validateWithRules(cl, new NoStaticExceptFinalRule())));
}
@TestFactory
Collection<DynamicTest> validateNoPublicFields() {
return getPojoClasses()
Stream<DynamicTest> validateNoPublicFields() {
return pojoClasses.stream()
.map(
cl ->
DynamicTest.dynamicTest(
"Check public fields for " + cl.getSimpleName(),
() -> validateWithRules(cl, new NoPublicFieldsRule())))
.collect(Collectors.toList());
() -> validateWithRules(cl, new NoPublicFieldsRule())));
}
private void validateWithRules(Class<?> cl, Rule... rules) {
@ -112,11 +114,12 @@ class PojoTest {
.verify();
}
private Stream<Class<?>> getPojoClasses() {
private static List<Class<?>> getPojoClasses() {
// TODO how to identify pojos? Is overwritten equals method enough?
return new ClassFileImporter()
.importPackages("pro.taskana").stream()
.filter(javaClass -> javaClass.tryGetMethod("equals", Object.class).isPresent())
.map(JavaClass::reflect);
.map(JavaClass::reflect)
.collect(Collectors.toList());
}
}

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

@ -2,7 +2,6 @@ package pro.taskana.classification.internal;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.SQLException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
@ -16,17 +15,11 @@ import org.junit.jupiter.api.Test;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.sampledata.SampleDataGenerator;
@ -43,7 +36,7 @@ class ClassificationServiceImplIntAutoCommitTest {
private ClassificationService classificationService;
@BeforeAll
static void beforeAll() throws SQLException {
static void beforeAll() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
@ -61,9 +54,7 @@ class ClassificationServiceImplIntAutoCommitTest {
}
@Test
void testFindAllClassifications()
throws ClassificationAlreadyExistException, NotAuthorizedException, DomainNotFoundException,
InvalidArgumentException {
void testFindAllClassifications() throws Exception {
Classification classification0 = classificationService.newClassification("TEST1", "", "TASK");
classificationService.createClassification(classification0);
Classification classification1 = classificationService.newClassification("TEST2", "", "TASK");
@ -76,10 +67,7 @@ class ClassificationServiceImplIntAutoCommitTest {
}
@Test
void testModifiedClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
void testModifiedClassification() throws Exception {
final String description = "TEST SOMETHING";
Classification classification =
classificationService.newClassification("TEST434", "DOMAIN_A", "TASK");
@ -95,9 +83,7 @@ class ClassificationServiceImplIntAutoCommitTest {
}
@Test
void testInsertClassification()
throws NotAuthorizedException, ClassificationAlreadyExistException, InvalidArgumentException,
DomainNotFoundException {
void testInsertClassification() throws Exception {
Classification classification =
classificationService.newClassification("TEST1333", "DOMAIN_A", "TASK");
classificationService.createClassification(classification);
@ -113,10 +99,7 @@ class ClassificationServiceImplIntAutoCommitTest {
}
@Test
void testUpdateClassification()
throws NotAuthorizedException, ClassificationAlreadyExistException,
ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
void testUpdateClassification() throws Exception {
Classification classification =
classificationService.newClassification("TEST32451", "DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
@ -137,10 +120,7 @@ class ClassificationServiceImplIntAutoCommitTest {
}
@Test
void testDefaultSettings()
throws NotAuthorizedException, ClassificationAlreadyExistException,
ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
void testDefaultSettings() throws Exception {
Classification classification =
classificationService.newClassification("TEST7771", "DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);

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

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Connection;
import java.sql.SQLException;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
@ -14,24 +13,17 @@ import java.util.List;
import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.sampledata.SampleDataGenerator;
@ -41,7 +33,7 @@ import pro.taskana.sampledata.SampleDataGenerator;
*
* @author BBR
*/
public class ClassificationServiceImplIntExplicitTest {
class ClassificationServiceImplIntExplicitTest {
private static final String ID_PREFIX_CLASSIFICATION = "CLI";
@ -50,40 +42,30 @@ public class ClassificationServiceImplIntExplicitTest {
private DataSource dataSource;
private ClassificationService classificationService;
private TaskanaEngineConfiguration taskanaEngineConfiguration;
private TaskanaEngine taskanaEngine;
private TaskanaEngineImpl taskanaEngineImpl;
@BeforeAll
public static void resetDb() {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
}
private TaskanaEngineImpl taskanaEngine;
@BeforeEach
public void setup() throws SQLException {
void setup() throws Exception {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration =
new TaskanaEngineConfiguration(dataSource, false, false, schemaName);
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngine = (TaskanaEngineImpl) taskanaEngineConfiguration.buildTaskanaEngine();
taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.EXPLICIT);
classificationService = taskanaEngine.getClassificationService();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
taskanaEngineImpl.setConnectionManagementMode(ConnectionManagementMode.EXPLICIT);
SampleDataGenerator sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
sampleDataGenerator.clearDb();
}
@AfterEach
public void cleanUp() throws SQLException {
taskanaEngineImpl.setConnection(null);
void cleanUp() throws Exception {
taskanaEngine.setConnection(null);
}
@Test
public void testInsertClassification()
throws SQLException, ClassificationNotFoundException, ClassificationAlreadyExistException,
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
void testInsertClassification() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
final String domain = "DOMAIN_A";
final String key = "dummy-key";
@ -128,11 +110,9 @@ public class ClassificationServiceImplIntExplicitTest {
}
@Test
public void testFindAllClassifications()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
DomainNotFoundException, InvalidArgumentException {
void testFindAllClassifications() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification0);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
@ -147,13 +127,10 @@ public class ClassificationServiceImplIntExplicitTest {
}
@Test
public void testModifiedClassification()
throws SQLException, ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
void testModifiedClassification() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
connection.commit();
classification = classificationService.createClassification(classification);
@ -171,11 +148,9 @@ public class ClassificationServiceImplIntExplicitTest {
}
@Test
public void testInsertAndClassificationQuery()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
DomainNotFoundException, InvalidArgumentException {
void testInsertAndClassificationQuery() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classificationService.createClassification(classification);
List<ClassificationSummary> list =
@ -189,12 +164,9 @@ public class ClassificationServiceImplIntExplicitTest {
}
@Test
public void testUpdateAndClassificationQuery()
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
ClassificationNotFoundException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
void testUpdateAndClassificationQuery() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification.setDescription("");
classification = classificationService.createClassification(classification);
@ -222,12 +194,9 @@ public class ClassificationServiceImplIntExplicitTest {
}
@Test
public void testDefaultSettingsWithClassificationQuery()
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
ClassificationNotFoundException, InvalidArgumentException, ConcurrencyException,
DomainNotFoundException {
void testDefaultSettingsWithClassificationQuery() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
taskanaEngine.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);

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

@ -12,10 +12,9 @@ import pro.taskana.common.api.TaskanaEngine;
*/
public class TaskanaEngineProxyForTest {
private InternalTaskanaEngine engine;
private final InternalTaskanaEngine engine;
public TaskanaEngineProxyForTest(TaskanaEngine taskanaEngine)
throws NoSuchFieldException, IllegalAccessException {
public TaskanaEngineProxyForTest(TaskanaEngine taskanaEngine) throws Exception {
Field internal = TaskanaEngineImpl.class.getDeclaredField("internalTaskanaEngineImpl");
internal.setAccessible(true);
engine = (InternalTaskanaEngine) internal.get(taskanaEngine);

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

@ -2,7 +2,6 @@ package pro.taskana.common.internal;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.junit.jupiter.api.Test;
@ -14,7 +13,7 @@ import pro.taskana.common.api.TaskanaEngine;
class TaskanaEngineTestConfigurationTest {
@Test
void testCreateTaskanaEngine() throws SQLException {
void testCreateTaskanaEngine() throws Exception {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
TaskanaEngineConfiguration taskEngineConfiguration =
new TaskanaEngineConfiguration(ds, false, TaskanaEngineTestConfiguration.getSchemaName());
@ -25,7 +24,7 @@ class TaskanaEngineTestConfigurationTest {
}
@Test
void should_SetCorpusChristiEnabled_When_PropertyIsSet() throws SQLException {
void should_SetCorpusChristiEnabled_When_PropertyIsSet() throws Exception {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
TaskanaEngineConfiguration taskEngineConfiguration =
new TaskanaEngineConfiguration(
@ -41,7 +40,7 @@ class TaskanaEngineTestConfigurationTest {
@Test
void should_returnTheTwoCustomHolidays_When_twoCustomHolidaysAreConfiguredInThePropertiesFile()
throws SQLException {
throws Exception {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
TaskanaEngineConfiguration taskEngineConfiguration =
new TaskanaEngineConfiguration(
@ -57,7 +56,7 @@ class TaskanaEngineTestConfigurationTest {
@Test
void should_returnEmptyCustomHolidaysList_When_allCustomHolidaysAreInWrongFormatInPropertiesFile()
throws SQLException {
throws Exception {
DataSource ds = TaskanaEngineTestConfiguration.getDataSource();
TaskanaEngineConfiguration taskEngineConfiguration =
new TaskanaEngineConfiguration(

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

@ -23,8 +23,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.reports.CategoryReport;
@ -53,8 +51,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfCatgoryReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfCatgoryReport() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -110,8 +107,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testGetCategoryReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetCategoryReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -172,8 +168,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testListTaskIdsOfCategoryReportForSelectedItems()
throws InvalidArgumentException, NotAuthorizedException {
void testListTaskIdsOfCategoryReportForSelectedItems() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -238,8 +233,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testListTaskIdsForSelectedItemsIsEmptyResult()
throws NotAuthorizedException, InvalidArgumentException {
void testListTaskIdsForSelectedItemsIsEmptyResult() throws Exception {
SelectedItem selectedItem = new SelectedItem();
List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
List<String> result =
@ -248,7 +242,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -308,8 +302,7 @@ class CategoryReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult()
throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult() throws Exception {
List<String> result =
cut.createCategoryReportBuilder()
.workbasketIdIn(Collections.singletonList("DieGibtsSicherNed"))

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

@ -23,8 +23,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.reports.ClassificationReport;
@ -56,8 +54,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfClassificationReport() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -115,8 +112,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetClassificationReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetClassificationReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -181,8 +177,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfDetailedClassificationReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfDetailedClassificationReport() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -244,8 +239,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetDetailedClassificationReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetDetailedClassificationReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -315,7 +309,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetTaskIdsForSelectedItems() throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsForSelectedItems() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -381,8 +375,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testGetTaskIdsForSelectedItemsIsEmptyResult()
throws NotAuthorizedException, InvalidArgumentException {
void testGetTaskIdsForSelectedItemsIsEmptyResult() throws Exception {
SelectedItem selectedItem = new SelectedItem();
selectedItem.setKey("GIBTSNED");
List<SelectedItem> selectedItems = Collections.singletonList(selectedItem);
@ -394,7 +387,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -455,8 +448,7 @@ class ClassificationReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult()
throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult() throws Exception {
List<String> result =
cut.createClassificationReportBuilder()
.workbasketIdIn(Collections.singletonList("DieGibtsGarantiertNed"))

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

@ -22,8 +22,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.SelectedItem;
import pro.taskana.monitor.api.reports.CustomFieldValueReport;
@ -52,8 +50,7 @@ class CustomFieldValueReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfCustomFieldValueReport()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfCustomFieldValueReport() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -110,8 +107,7 @@ class CustomFieldValueReportBuilderImplTest {
}
@Test
void testGetCustomFieldValueReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetCustomFieldValueReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -173,7 +169,7 @@ class CustomFieldValueReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);

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

@ -19,8 +19,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.reports.TaskStatusReport;
import pro.taskana.monitor.api.reports.item.TaskQueryItem;
@ -44,8 +42,7 @@ class TaskStatusReportBuilderImplTest {
}
@Test
void testGetTaskStateReportWithoutFilters()
throws NotAuthorizedException, InvalidArgumentException {
void testGetTaskStateReportWithoutFilters() throws Exception {
// given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);
@ -80,8 +77,7 @@ class TaskStatusReportBuilderImplTest {
}
@Test
void testGetTotalNumberOfTaskStateReport()
throws NotAuthorizedException, InvalidArgumentException {
void testGetTotalNumberOfTaskStateReport() throws Exception {
// given
TaskQueryItem queryItem1 = new TaskQueryItem();
queryItem1.setCount(50);

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

@ -26,7 +26,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaRole;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.monitor.api.CombinedClassificationFilter;
import pro.taskana.monitor.api.SelectedItem;
@ -54,8 +53,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfWorkbasketReportBasedOnDueDate()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfWorkbasketReportBasedOnDueDate() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -115,8 +113,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testGetWorkbasketReportWithReportLineItemDefinitions()
throws InvalidArgumentException, NotAuthorizedException {
void testGetWorkbasketReportWithReportLineItemDefinitions() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -182,8 +179,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testGetTaskIdsOfCategoryReportForSelectedItems()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTaskIdsOfCategoryReportForSelectedItems() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -258,7 +254,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeName() throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeName() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);
@ -314,8 +310,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult()
throws NotAuthorizedException {
void testListCustomAttributeValuesForCustomAttributeNameIsEmptyResult() throws Exception {
List<String> result =
cut.createWorkbasketReportBuilder()
.workbasketIdIn(Arrays.asList("GibtsSicherNed"))
@ -324,8 +319,7 @@ class WorkbasketReportBuilderImplTest {
}
@Test
void testGetTotalNumbersOfWorkbasketReportBasedOnCreatedDate()
throws InvalidArgumentException, NotAuthorizedException {
void testGetTotalNumbersOfWorkbasketReportBasedOnCreatedDate() throws Exception {
final List<String> workbasketIds =
Collections.singletonList("WBI:000000000000000000000000000000000001");
final List<TaskState> states = Arrays.asList(TaskState.CLAIMED, TaskState.READY);

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

@ -10,7 +10,6 @@ import org.junit.jupiter.api.Test;
import pro.taskana.common.api.CustomHoliday;
import pro.taskana.common.api.WorkingDaysToDaysConverter;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.monitor.api.reports.header.TimeIntervalColumnHeader;
import pro.taskana.monitor.internal.preprocessor.WorkingDaysToDaysReportConverter;
@ -27,7 +26,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_AssertNotEqual_When_InitializingDifferentDates() throws InvalidArgumentException {
void should_AssertNotEqual_When_InitializingDifferentDates() throws Exception {
WorkingDaysToDaysReportConverter instance1 =
WorkingDaysToDaysReportConverter.initialize(
getShortListOfColumnHeaders(), converter, Instant.parse("2018-02-04T00:00:00.000Z"));
@ -39,7 +38,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDays() throws InvalidArgumentException {
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDays() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-02-06T00:00:00.000Z"));
@ -68,7 +67,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDaysUnchanged_When_ConvertingWorkingDaysOutOfNegativeLimit()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-02-06T00:00:00.000Z"));
@ -78,7 +77,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDaysUnchanged_When_ConvertingWorkingDaysOutOfPositiveLimit()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-02-06T00:00:00.000Z"));
@ -87,8 +86,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnAllMatchingDays_When_ConvertingWorkingDaysToDays()
throws InvalidArgumentException {
void should_ReturnAllMatchingDays_When_ConvertingWorkingDaysToDays() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-02-27T00:00:00.000Z"));
@ -122,8 +120,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnAllMatchingDays_When_ConvertingWorkingDaysToDaysAtWeekend()
throws InvalidArgumentException {
void should_ReturnAllMatchingDays_When_ConvertingWorkingDaysToDaysAtWeekend() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-03-10T00:00:00.000Z"));
@ -158,7 +155,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnAllMatchingDays_When_ConvertingWorkingDaysToDaysOnEasterSunday()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-04-01T00:00:00.000Z"));
@ -193,7 +190,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnEasterHolidays()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-03-28T00:00:00.000Z"));
@ -209,7 +206,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnWhitsunHolidays()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-05-16T00:00:00.000Z"));
@ -224,8 +221,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnLabourDay()
throws InvalidArgumentException {
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnLabourDay() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-04-26T00:00:00.000Z"));
@ -241,8 +237,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnAscensionDay()
throws InvalidArgumentException {
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnAscensionDay() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-05-07T00:00:00.000Z"));
@ -259,7 +254,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnDayOfGermanUnity()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-10-01T00:00:00.000Z"));
@ -276,7 +271,7 @@ class WorkingDaysToDaysReportConverterTest {
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnChristmasAndNewYearHolidays()
throws InvalidArgumentException {
throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-12-20T00:00:00.000Z"));
@ -299,8 +294,7 @@ class WorkingDaysToDaysReportConverterTest {
}
@Test
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnCustomHoliday()
throws InvalidArgumentException {
void should_ReturnWorkingDays_When_ConvertingDaysToWorkingDaysOnCustomHoliday() throws Exception {
WorkingDaysToDaysReportConverter instance =
WorkingDaysToDaysReportConverter.initialize(
getLargeListOfColumnHeaders(), converter, Instant.parse("2018-10-26T00:00:00.000Z"));

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

@ -3,7 +3,6 @@ package pro.taskana.task.internal;
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;
@ -16,17 +15,12 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.common.internal.security.CurrentUserContext;
@ -35,8 +29,6 @@ import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.task.api.TaskState;
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.ObjectReference;
import pro.taskana.task.api.models.Task;
@ -44,10 +36,6 @@ import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
@ -70,7 +58,7 @@ class TaskServiceImplIntAutocommitTest {
private WorkbasketService workbasketService;
@BeforeAll
static void beforeAll() throws SQLException {
static void beforeAll() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
sampleDataGenerator = new SampleDataGenerator(dataSource, schemaName);
@ -94,11 +82,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void testStart()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
ClassificationNotFoundException, ClassificationAlreadyExistException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException {
void testStart() throws Exception {
Workbasket wb = workbasketService.newWorkbasket("workbasket", "DOMAIN_A");
wb.setName("workbasket");
@ -123,11 +107,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void testStartTransactionFail()
throws TaskNotFoundException, NotAuthorizedException, WorkbasketNotFoundException,
ClassificationNotFoundException, ClassificationAlreadyExistException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException {
void testStartTransactionFail() throws Exception {
Workbasket wb = workbasketService.newWorkbasket("wb1k1", "DOMAIN_A");
wb.setName("sdf");
@ -160,11 +140,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void should_ReturnList_when_BuilderIsUsed()
throws NotAuthorizedException, WorkbasketNotFoundException, ClassificationNotFoundException,
ClassificationAlreadyExistException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, SystemException,
WorkbasketAlreadyExistException, DomainNotFoundException {
void should_ReturnList_when_BuilderIsUsed() throws Exception {
Workbasket wb = workbasketService.newWorkbasket("key", "DOMAIN_A");
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
@ -202,11 +178,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void shouldTransferTaskToOtherWorkbasket()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException, InvalidStateException {
void shouldTransferTaskToOtherWorkbasket() throws Exception {
final int sleepTime = 100;
// Source Workbasket
@ -267,11 +239,7 @@ class TaskServiceImplIntAutocommitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void shouldNotTransferByFailingSecurity()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, SQLException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException, WorkbasketAccessItemAlreadyExistException {
void shouldNotTransferByFailingSecurity() throws Exception {
final String user = CurrentUserContext.getUserid();
// Set up Security for this Test
@ -367,11 +335,7 @@ class TaskServiceImplIntAutocommitTest {
}
@Test
void testWithPrimaryObjectRef()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
ClassificationNotFoundException, ClassificationAlreadyExistException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException {
void testWithPrimaryObjectRef() throws Exception {
Workbasket wb = workbasketService.newWorkbasket("workbasket", "DOMAIN_A");
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
@ -409,8 +373,7 @@ class TaskServiceImplIntAutocommitTest {
boolean permRead,
boolean permAppend,
boolean permTransfer)
throws InvalidArgumentException, NotAuthorizedException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
throws Exception {
WorkbasketAccessItem accessItem =
workbasketService.newWorkbasketAccessItem(wb.getId(), accessId);
accessItem.setPermOpen(permOpen);

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

@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.io.File;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;
import javax.sql.DataSource;
@ -18,17 +17,13 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.common.internal.configuration.DbSchemaCreator;
@ -38,17 +33,13 @@ import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.task.api.TaskState;
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.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
@ -73,7 +64,7 @@ class TaskServiceImplIntExplicitTest {
private WorkbasketService workbasketService;
@BeforeAll
static void beforeAll() throws SQLException {
static void beforeAll() throws Exception {
String userHomeDirectory = System.getProperty("user.home");
String propertiesFileName = userHomeDirectory + "/taskanaUnitTest.properties";
@ -89,7 +80,7 @@ class TaskServiceImplIntExplicitTest {
}
@BeforeEach
void setup() throws SQLException {
void setup() throws Exception {
taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
taskServiceImpl = (TaskServiceImpl) taskanaEngine.getTaskService();
taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
@ -110,12 +101,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testStartTransactionFail()
throws SQLException, TaskNotFoundException, NotAuthorizedException,
WorkbasketNotFoundException, ClassificationNotFoundException,
ClassificationAlreadyExistException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException, WorkbasketAccessItemAlreadyExistException {
void testStartTransactionFail() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
@ -158,12 +144,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testCreateTask()
throws SQLException, TaskNotFoundException, NotAuthorizedException,
WorkbasketNotFoundException, ClassificationNotFoundException,
ClassificationAlreadyExistException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException, WorkbasketAccessItemAlreadyExistException {
void testCreateTask() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
@ -190,10 +171,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void createTaskShouldThrowWorkbasketNotFoundException()
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException {
void createTaskShouldThrowWorkbasketNotFoundException() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
Task test = this.generateDummyTask();
@ -209,11 +187,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void createManualTaskShouldThrowClassificationNotFoundException()
throws NotAuthorizedException, WorkbasketNotFoundException, SQLException,
ClassificationAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
WorkbasketAlreadyExistException, DomainNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void createManualTaskShouldThrowClassificationNotFoundException() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
@ -244,12 +218,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void should_ReturnList_when_BuilderIsUsed()
throws SQLException, NotAuthorizedException, WorkbasketNotFoundException,
ClassificationNotFoundException, ClassificationAlreadyExistException,
TaskAlreadyExistException, InvalidWorkbasketException, InvalidArgumentException,
SystemException, WorkbasketAlreadyExistException, DomainNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void should_ReturnList_when_BuilderIsUsed() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
WorkbasketImpl workbasket =
@ -299,12 +268,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void shouldTransferTaskToOtherWorkbasket()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, TaskNotFoundException, InterruptedException,
TaskAlreadyExistException, SQLException, InvalidWorkbasketException,
InvalidArgumentException, WorkbasketAlreadyExistException, DomainNotFoundException,
InvalidStateException, WorkbasketAccessItemAlreadyExistException {
void shouldTransferTaskToOtherWorkbasket() throws Exception {
final int sleepTime = 100;
final String user = CurrentUserContext.getUserid();
try (Connection connection = dataSource.getConnection()) {
@ -377,7 +341,7 @@ class TaskServiceImplIntExplicitTest {
}
@Test
void shouldNotTransferAnyTask() throws SQLException {
void shouldNotTransferAnyTask() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
@ -391,11 +355,7 @@ class TaskServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void shouldNotTransferByFailingSecurity()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, SQLException, TaskAlreadyExistException,
InvalidWorkbasketException, InvalidArgumentException, WorkbasketAlreadyExistException,
DomainNotFoundException, WorkbasketAccessItemAlreadyExistException {
void shouldNotTransferByFailingSecurity() throws Exception {
final String user = "user-1-1";
// Set up Security for this Test
@ -496,14 +456,11 @@ class TaskServiceImplIntExplicitTest {
}
@AfterEach
void cleanUp() throws SQLException {
void cleanUp() throws Exception {
taskanaEngineImpl.setConnection(null);
}
private Task generateDummyTask()
throws ClassificationAlreadyExistException, InvalidWorkbasketException,
NotAuthorizedException, WorkbasketAlreadyExistException, DomainNotFoundException,
InvalidArgumentException {
private Task generateDummyTask() throws Exception {
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("wb", "DOMAIN_A");
workbasket.setName("wb");
workbasket.setId("1"); // set id manually for authorization tests

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

@ -137,7 +137,7 @@ class TaskServiceImplTest {
}
@Test
void testTaskSummaryEqualsHashCode() throws InterruptedException {
void testTaskSummaryEqualsHashCode() throws Exception {
Classification classification = CreateTaskModelHelper.createDummyClassification();
Workbasket wb = CreateTaskModelHelper.createWorkbasket("WB-ID", "WB-Key");
ObjectReference objectReference = JunitHelper.createDefaultObjRef();

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

@ -19,16 +19,12 @@ import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.internal.ClassificationQueryImpl;
import pro.taskana.classification.internal.ClassificationServiceImpl;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketPermission;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
/**
@ -63,9 +59,7 @@ class TaskTransferrerTest {
@Mock private SqlSession sqlSessionMock;
@Test
void testTransferTaskToDestinationWorkbasketWithoutSecurity()
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
InvalidStateException {
void testTransferTaskToDestinationWorkbasketWithoutSecurity() throws Exception {
doReturn(taskanaEngineMock).when(internalTaskanaEngineMock).getEngine();
doReturn(workbasketServiceMock).when(taskanaEngineMock).getWorkbasketService();
cut = new TaskTransferrer(internalTaskanaEngineMock, taskMapperMock, taskServiceImplMock);

40
lib/taskana-core/src/test/java/pro/taskana/task/internal/models/MinimalTaskSummaryTest.java
View File

@ -1,40 +0,0 @@
package pro.taskana.task.internal.models;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import org.junit.jupiter.api.Test;
import pro.taskana.task.api.CallbackState;
import pro.taskana.task.api.TaskState;
public class MinimalTaskSummaryTest {
@Test
void testMinimalTaskSummary() {
Instant now = Instant.now();
MinimalTaskSummary summary = new MinimalTaskSummary();
summary.setTaskId("task1");
summary.setExternalId("exid");
summary.setWorkbasketId("wb1");
summary.setClassificationId("cfid");
summary.setOwner("owner");
summary.setTaskState(TaskState.CLAIMED);
summary.setPlanned(now);
summary.setDue(now);
summary.setModified(now);
summary.setCallbackState(CallbackState.CALLBACK_PROCESSING_REQUIRED);
assertThat(summary.getTaskId()).isEqualTo("task1");
assertThat(summary.getExternalId()).isEqualTo("exid");
assertThat(summary.getWorkbasketId()).isEqualTo("wb1");
assertThat(summary.getClassificationId()).isEqualTo("cfid");
assertThat(summary.getOwner()).isEqualTo("owner");
assertThat(summary.getTaskState()).isEqualTo(TaskState.CLAIMED);
assertThat(summary.getPlanned()).isEqualTo(now);
assertThat(summary.getDue()).isEqualTo(now);
assertThat(summary.getModified()).isEqualTo(now);
assertThat(summary.getCallbackState()).isEqualTo(CallbackState.CALLBACK_PROCESSING_REQUIRED);
String summaryAsString = summary.toString();
assertThat(summaryAsString).isNotNull();
}
}

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

@ -3,7 +3,6 @@ package pro.taskana.workbasket.internal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -17,9 +16,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
@ -27,9 +23,6 @@ import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
@ -56,7 +49,7 @@ class WorkbasketServiceImplIntAutocommitTest {
}
@BeforeEach
void setup() throws SQLException {
void setup() throws Exception {
DataSource dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
TaskanaEngineConfiguration taskanaEngineConfiguration =
@ -130,10 +123,7 @@ class WorkbasketServiceImplIntAutocommitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testInsertWorkbasketAccessUser()
throws NotAuthorizedException, InvalidArgumentException, DomainNotFoundException,
InvalidWorkbasketException, WorkbasketAlreadyExistException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
void testInsertWorkbasketAccessUser() throws Exception {
Workbasket wb =
createTestWorkbasket(
@ -159,10 +149,7 @@ class WorkbasketServiceImplIntAutocommitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testUpdateWorkbasketAccessUser()
throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException,
DomainNotFoundException, InvalidWorkbasketException, WorkbasketAlreadyExistException,
WorkbasketAccessItemAlreadyExistException {
void testUpdateWorkbasketAccessUser() throws Exception {
WorkbasketImpl wb = (WorkbasketImpl) workBasketService.newWorkbasket("key", "DOMAIN_A");
wb.setId("k200000000000000000000000000000000000000");
wb.setName("name");
@ -200,8 +187,7 @@ class WorkbasketServiceImplIntAutocommitTest {
boolean permRead,
boolean permAppend,
boolean permTransfer)
throws InvalidArgumentException, NotAuthorizedException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
throws Exception {
WorkbasketAccessItem accessItem =
workBasketService.newWorkbasketAccessItem(wb.getId(), accessId);
accessItem.setPermOpen(permOpen);

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

@ -3,7 +3,6 @@ package pro.taskana.workbasket.internal;
import static org.assertj.core.api.Assertions.assertThat;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@ -17,9 +16,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.common.internal.security.JaasExtension;
@ -28,10 +24,6 @@ import pro.taskana.common.internal.util.IdGenerator;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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.api.models.WorkbasketSummary;
@ -63,7 +55,7 @@ class WorkbasketServiceImplIntExplicitTest {
}
@BeforeEach
void setup() throws SQLException {
void setup() throws Exception {
dataSource = TaskanaEngineTestConfiguration.getDataSource();
String schemaName = TaskanaEngineTestConfiguration.getSchemaName();
taskanaEngineConfiguration = new TaskanaEngineConfiguration(dataSource, false, schemaName);
@ -132,10 +124,7 @@ class WorkbasketServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testInsertWorkbasketAccessUser()
throws NotAuthorizedException, SQLException, InvalidArgumentException,
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
WorkbasketAlreadyExistException, WorkbasketAccessItemAlreadyExistException {
void testInsertWorkbasketAccessUser() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
workBasketService = taskanaEngine.getWorkbasketService();
@ -155,10 +144,7 @@ class WorkbasketServiceImplIntExplicitTest {
@WithAccessId(user = "user-1-1", groups = "businessadmin")
@Test
void testUpdateWorkbasketAccessUser()
throws NotAuthorizedException, SQLException, InvalidArgumentException,
WorkbasketNotFoundException, DomainNotFoundException, InvalidWorkbasketException,
WorkbasketAlreadyExistException, WorkbasketAccessItemAlreadyExistException {
void testUpdateWorkbasketAccessUser() throws Exception {
try (Connection connection = dataSource.getConnection()) {
taskanaEngineImpl.setConnection(connection);
workBasketService = taskanaEngine.getWorkbasketService();
@ -179,7 +165,7 @@ class WorkbasketServiceImplIntExplicitTest {
}
@AfterEach
void cleanUp() throws SQLException {
void cleanUp() throws Exception {
taskanaEngineImpl.setConnection(null);
}
@ -190,8 +176,7 @@ class WorkbasketServiceImplIntExplicitTest {
boolean permRead,
boolean permAppend,
boolean permTransfer)
throws InvalidArgumentException, NotAuthorizedException, WorkbasketNotFoundException,
WorkbasketAccessItemAlreadyExistException {
throws Exception {
WorkbasketAccessItem accessItem =
workBasketService.newWorkbasketAccessItem(wb.getId(), accessId);
accessItem.setPermOpen(permOpen);

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

@ -31,15 +31,11 @@ import org.mockito.junit.jupiter.MockitoExtension;
import pro.taskana.TaskanaEngineConfiguration;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.ConcurrencyException;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.internal.InternalTaskanaEngine;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
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;
@ -78,9 +74,7 @@ class WorkbasketServiceImplTest {
}
@Test
void testCreateWorkbasket_WithDistibutionTargets()
throws WorkbasketNotFoundException, NotAuthorizedException, InvalidWorkbasketException,
WorkbasketAlreadyExistException, DomainNotFoundException {
void testCreateWorkbasket_WithDistibutionTargets() throws Exception {
final int distTargetAmount = 2;
WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(any());
@ -159,7 +153,7 @@ class WorkbasketServiceImplTest {
}
@Test
void testDeleteWorkbasketIsUsed() throws NotAuthorizedException, WorkbasketNotFoundException {
void testDeleteWorkbasketIsUsed() throws Exception {
Workbasket wb = createTestWorkbasket("WBI:0", "wb-key");
ThrowingCallable call =
@ -228,9 +222,7 @@ class WorkbasketServiceImplTest {
return workbasket;
}
private List<String> createTestDistributionTargets(int amount)
throws InvalidWorkbasketException, NotAuthorizedException, WorkbasketAlreadyExistException,
DomainNotFoundException {
private List<String> createTestDistributionTargets(int amount) throws Exception {
List<String> distributionsTargets = new ArrayList<>();
amount = Math.max(amount, 0);
for (int i = 0; i < amount; i++) {

10
lib/taskana-spring-example/src/test/java/pro/taskana/TaskanaTransactionIntTest.java
View File

@ -4,7 +4,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import javax.sql.DataSource;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
@ -23,8 +22,6 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.api.exceptions.TaskanaException;
import pro.taskana.common.internal.TaskanaEngineImpl;
import pro.taskana.common.internal.transaction.TaskanaTransactionProvider;
@ -37,10 +34,7 @@ import pro.taskana.task.internal.jobs.TaskCleanupJob;
import pro.taskana.task.internal.models.TaskImpl;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.InvalidWorkbasketException;
import pro.taskana.workbasket.api.exceptions.WorkbasketAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketInUseException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
import pro.taskana.workbasket.internal.jobs.WorkbasketCleanupJob;
import pro.taskana.workbasket.internal.models.WorkbasketImpl;
@ -151,9 +145,7 @@ class TaskanaTransactionIntTest {
}
@Test
void testTransactionCustomDbWithSchemaSetToTaskana()
throws SQLException, NotAuthorizedException, WorkbasketNotFoundException,
DomainNotFoundException, InvalidWorkbasketException, WorkbasketAlreadyExistException {
void testTransactionCustomDbWithSchemaSetToTaskana() throws Exception {
final TaskanaEngineImpl taskanaEngineImpl = (TaskanaEngineImpl) taskanaEngine;
try (Connection connection = dataSource.getConnection()) {

11
lib/taskana-spring/src/test/java/pro/taskana/common/internal/transaction/TransactionTest.java
View File

@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
@ -32,14 +31,14 @@ import pro.taskana.task.api.TaskService;
@EnableAutoConfiguration
@DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD)
@Disabled
public class TransactionTest {
class TransactionTest {
@Autowired TaskService taskService;
@LocalServerPort int port;
@Autowired private TestRestTemplate restTemplate;
@BeforeEach
public void init() throws SQLException, ClassNotFoundException {
void init() throws Exception {
Class.forName("org.h2.Driver");
try (Connection conn = getConnection()) {
try (Statement statement = conn.createStatement()) {
@ -50,7 +49,7 @@ public class TransactionTest {
}
@Test
public void testCommit() throws SQLException {
void testCommit() throws Exception {
restTemplate.getForEntity("http://127.0.0.1:" + port + "/test", String.class);
int resultCount = 0;
@ -68,7 +67,7 @@ public class TransactionTest {
}
@Test
public void testRollback() throws SQLException {
void testRollback() throws Exception {
restTemplate.postForEntity("http://127.0.0.1:" + port + "/test", null, String.class);
int resultCount = 0;
@ -85,7 +84,7 @@ public class TransactionTest {
}
}
private Connection getConnection() throws SQLException {
private Connection getConnection() throws Exception {
return DriverManager.getConnection(
"jdbc:h2:mem:task-engine;IGNORECASE=TRUE;LOCK_MODE=0", "SA", UUID.randomUUID().toString());
}

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

@ -7,7 +7,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import pro.taskana.TaskanaSpringBootTest;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.rest.ldap.LdapClient;
import pro.taskana.common.rest.models.AccessIdRepresentationModel;
@ -18,7 +17,7 @@ class LdapTest {
@Autowired private LdapClient ldapClient;
@Test
void testFindUsers() throws InvalidArgumentException {
void testFindUsers() throws Exception {
List<AccessIdRepresentationModel> usersAndGroups = ldapClient.searchUsersAndGroups("lead");
assertThat(usersAndGroups)
.extracting(AccessIdRepresentationModel::getAccessId)

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

@ -7,7 +7,6 @@ import static pro.taskana.common.rest.RestHelper.TEMPLATE;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
@ -34,7 +33,6 @@ import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpStatusCodeException;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.rest.assembler.ClassificationRepresentationModelAssembler;
import pro.taskana.classification.rest.models.ClassificationRepresentationModel;
import pro.taskana.classification.rest.models.ClassificationSummaryRepresentationModel;
@ -106,7 +104,7 @@ class ClassificationDefinitionControllerIntTest {
}
@Test
void testImportFilledClassification() throws IOException {
void testImportFilledClassification() throws Exception {
ClassificationRepresentationModel classification = new ClassificationRepresentationModel();
classification.setClassificationId("classificationId_");
classification.setKey("key drelf");
@ -141,7 +139,7 @@ class ClassificationDefinitionControllerIntTest {
}
@Test
void testFailureWhenKeyIsMissing() throws IOException {
void testFailureWhenKeyIsMissing() throws Exception {
ClassificationRepresentationModel classification = new ClassificationRepresentationModel();
classification.setDomain("DOMAIN_A");
TaskanaPagedModel<ClassificationRepresentationModel> clList =
@ -156,7 +154,7 @@ class ClassificationDefinitionControllerIntTest {
}
@Test
void testFailureWhenDomainIsMissing() throws IOException {
void testFailureWhenDomainIsMissing() throws Exception {
ClassificationRepresentationModel classification = new ClassificationRepresentationModel();
classification.setKey("one");
TaskanaPagedModel<ClassificationRepresentationModel> clList =
@ -187,7 +185,7 @@ class ClassificationDefinitionControllerIntTest {
}
@Test
void testImportMultipleClassifications() throws IOException {
void testImportMultipleClassifications() throws Exception {
ClassificationRepresentationModel classification1 =
this.createClassification("id1", "ImportKey1", "DOMAIN_A", null, null);
@ -423,12 +421,12 @@ class ClassificationDefinitionControllerIntTest {
}
private ClassificationRepresentationModel getClassificationWithKeyAndDomain(
String key, String domain) throws ClassificationNotFoundException {
String key, String domain) throws Exception {
return classificationAssembler.toModel(classificationService.getClassification(key, domain));
}
private ResponseEntity<Void> importRequest(
TaskanaPagedModel<ClassificationRepresentationModel> clList) throws IOException {
TaskanaPagedModel<ClassificationRepresentationModel> clList) throws Exception {
LOGGER.debug("Start Import");
File tmpFile = File.createTempFile("test", ".tmp");
OutputStreamWriter writer =

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

@ -23,7 +23,6 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.env.Environment;
import org.springframework.ldap.core.LdapTemplate;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.SystemException;
import pro.taskana.common.rest.models.AccessIdRepresentationModel;
@ -49,7 +48,7 @@ class LdapClientTest {
}
@Test
void testLdap_searchUsersAndGroups() throws InvalidArgumentException {
void testLdap_searchUsersAndGroups() throws Exception {
setUpEnvMock();
cut.init();

2
rest/taskana-rest-spring/src/test/java/pro/taskana/monitor/rest/models/ReportRepresentationModelTest.java
View File

@ -34,7 +34,7 @@ class ReportRepresentationModelTest {
private List<TimeIntervalColumnHeader> headers;
@Autowired
public ReportRepresentationModelTest(
ReportRepresentationModelTest(
ReportRepresentationModelAssembler reportRepresentationModelAssembler) {
this.reportRepresentationModelAssembler = reportRepresentationModelAssembler;
}

182
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/TaskCommentControllerIntTest.java
View File

@ -2,14 +2,13 @@ package pro.taskana.task.rest;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.rest.RestHelper.TEMPLATE;
import java.time.Instant;
import java.util.Comparator;
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.hateoas.IanaLinkRelations;
import org.springframework.http.HttpEntity;
@ -17,7 +16,6 @@ import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;
import pro.taskana.common.rest.Mapping;
import pro.taskana.common.rest.RestHelper;
@ -32,16 +30,12 @@ class TaskCommentControllerIntTest {
private static final ParameterizedTypeReference<TaskanaPagedModel<TaskCommentRepresentationModel>>
TASK_COMMENT_PAGE_MODEL_TYPE =
new ParameterizedTypeReference<TaskanaPagedModel<TaskCommentRepresentationModel>>() {};
private static RestTemplate template;
@Value("${taskana.schemaName:TASKANA}")
public String schemaName;
private final RestHelper restHelper;
@Autowired RestHelper restHelper;
@BeforeAll
static void init() {
template = RestHelper.TEMPLATE;
@Autowired
TaskCommentControllerIntTest(RestHelper restHelper) {
this.restHelper = restHelper;
}
@Test
@ -51,13 +45,12 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "Non existing task comment Id");
ThrowingCallable httpCall =
() -> {
template.exchange(
urlToNonExistingTaskComment,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
urlToNonExistingTaskComment,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.NOT_FOUND);
@ -70,13 +63,12 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000004");
ThrowingCallable httpCall =
() -> {
template.exchange(
urlToNotVisibleTask,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_1()),
TASK_COMMENT_PAGE_MODEL_TYPE);
};
() ->
TEMPLATE.exchange(
urlToNotVisibleTask,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_1()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.FORBIDDEN);
@ -90,12 +82,13 @@ class TaskCommentControllerIntTest {
ResponseEntity<TaskanaPagedModel<TaskCommentRepresentationModel>>
getTaskCommentsSortedByModifiedOrderedByDescendingResponse =
template.exchange(
TEMPLATE.exchange(
url + "?sort-by=modified&order=desc",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThat(getTaskCommentsSortedByModifiedOrderedByDescendingResponse.getBody()).isNotNull();
assertThat(getTaskCommentsSortedByModifiedOrderedByDescendingResponse.getBody().getContent())
.hasSize(3)
.extracting(TaskCommentRepresentationModel::getModified)
@ -103,12 +96,13 @@ class TaskCommentControllerIntTest {
ResponseEntity<TaskanaPagedModel<TaskCommentRepresentationModel>>
getTaskCommentsSortedByModifiedOrderedByAscendingResponse =
template.exchange(
TEMPLATE.exchange(
url + "?sort-by=modified",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThat(getTaskCommentsSortedByModifiedOrderedByAscendingResponse.getBody()).isNotNull();
assertThat(getTaskCommentsSortedByModifiedOrderedByAscendingResponse.getBody().getContent())
.hasSize(3)
.extracting(TaskCommentRepresentationModel::getModified)
@ -116,12 +110,13 @@ class TaskCommentControllerIntTest {
ResponseEntity<TaskanaPagedModel<TaskCommentRepresentationModel>>
getTaskCommentsSortedByCreatedOrderedByDescendingResponse =
template.exchange(
TEMPLATE.exchange(
url + "?sort-by=created&order=desc",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThat(getTaskCommentsSortedByCreatedOrderedByDescendingResponse.getBody()).isNotNull();
assertThat(getTaskCommentsSortedByCreatedOrderedByDescendingResponse.getBody().getContent())
.hasSize(3)
.extracting(TaskCommentRepresentationModel::getCreated)
@ -129,12 +124,13 @@ class TaskCommentControllerIntTest {
ResponseEntity<TaskanaPagedModel<TaskCommentRepresentationModel>>
getTaskCommentsSortedByCreatedOrderedByAscendingResponse =
template.exchange(
TEMPLATE.exchange(
url + "?sort-by=created",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThat(getTaskCommentsSortedByCreatedOrderedByAscendingResponse.getBody()).isNotNull();
assertThat(getTaskCommentsSortedByCreatedOrderedByAscendingResponse.getBody().getContent())
.hasSize(3)
.extracting(TaskCommentRepresentationModel::getCreated)
@ -148,13 +144,12 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000000");
ThrowingCallable httpCall =
() -> {
template.exchange(
url + "?sort-by=invalidSortParam",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_1()),
TASK_COMMENT_PAGE_MODEL_TYPE);
};
() ->
TEMPLATE.exchange(
url + "?sort-by=invalidSortParam",
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_1()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.BAD_REQUEST);
@ -167,13 +162,12 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000012");
ThrowingCallable httpCall =
() -> {
template.exchange(
urlToNotVisibleTask,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
urlToNotVisibleTask,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.FORBIDDEN);
@ -188,15 +182,14 @@ class TaskCommentControllerIntTest {
taskCommentRepresentationModelToCreate.setTextField("newly created task comment");
ThrowingCallable httpCall =
() -> {
template.exchange(
restHelper.toUrl(
Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000000"),
HttpMethod.POST,
new HttpEntity<>(
taskCommentRepresentationModelToCreate, restHelper.getHeadersUser_b_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
restHelper.toUrl(
Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000000"),
HttpMethod.POST,
new HttpEntity<>(
taskCommentRepresentationModelToCreate, restHelper.getHeadersUser_b_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.FORBIDDEN);
@ -211,14 +204,13 @@ class TaskCommentControllerIntTest {
taskCommentRepresentationModelToCreate.setTextField("newly created task comment");
ThrowingCallable httpCall =
() -> {
template.exchange(
restHelper.toUrl(Mapping.URL_TASK_COMMENTS, "DefinatelyNotExistingId"),
HttpMethod.POST,
new HttpEntity<>(
taskCommentRepresentationModelToCreate, restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
restHelper.toUrl(Mapping.URL_TASK_COMMENTS, "DefinatelyNotExistingId"),
HttpMethod.POST,
new HttpEntity<>(
taskCommentRepresentationModelToCreate, restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.NOT_FOUND);
@ -230,7 +222,7 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
ResponseEntity<TaskCommentRepresentationModel> getTaskCommentResponse =
template.exchange(
TEMPLATE.exchange(
url,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
@ -244,13 +236,12 @@ class TaskCommentControllerIntTest {
taskCommentToUpdate.setModified(Instant.now());
ThrowingCallable httpCall =
() -> {
template.exchange(
url,
HttpMethod.PUT,
new HttpEntity<>(taskCommentToUpdate, restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
url,
HttpMethod.PUT,
new HttpEntity<>(taskCommentToUpdate, restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.CONFLICT);
@ -262,7 +253,7 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
ResponseEntity<TaskCommentRepresentationModel> getTaskCommentResponse =
template.exchange(
TEMPLATE.exchange(
url,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_1()),
@ -277,7 +268,7 @@ class TaskCommentControllerIntTest {
ThrowingCallable httpCall =
() ->
template.exchange(
TEMPLATE.exchange(
url,
HttpMethod.PUT,
new HttpEntity<>(taskComment, restHelper.getHeadersUser_1_2()),
@ -294,11 +285,12 @@ class TaskCommentControllerIntTest {
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000000");
ResponseEntity<TaskCommentRepresentationModel> getTaskCommentResponse =
template.exchange(
TEMPLATE.exchange(
url,
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThat(getTaskCommentResponse.getBody()).isNotNull();
assertThat(getTaskCommentResponse.getBody().getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat(getTaskCommentResponse.getBody().getCreator()).isEqualTo("user-1-1");
assertThat(getTaskCommentResponse.getBody().getTextField()).isEqualTo("some text in textfield");
@ -309,14 +301,13 @@ class TaskCommentControllerIntTest {
taskCommentRepresentationModelToUpdate.setTaskCommentId("DifferentTaskCommentId");
ThrowingCallable httpCall =
() -> {
template.exchange(
url,
HttpMethod.PUT,
new HttpEntity<>(
taskCommentRepresentationModelToUpdate, restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
url,
HttpMethod.PUT,
new HttpEntity<>(
taskCommentRepresentationModelToUpdate, restHelper.getHeadersUser_1_1()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.BAD_REQUEST);
@ -326,26 +317,26 @@ class TaskCommentControllerIntTest {
void should_FailToDeleteTaskComment_When_UserHasNoAuthorization() {
ResponseEntity<TaskanaPagedModel<TaskCommentRepresentationModel>>
getTaskCommentsBeforeDeletionResponse =
template.exchange(
getTaskCommentsBeforeDeleteionResponse =
TEMPLATE.exchange(
restHelper.toUrl(
Mapping.URL_TASK_COMMENTS, "TKI:000000000000000000000000000000000001"),
HttpMethod.GET,
new HttpEntity<String>(restHelper.getHeadersUser_1_2()),
TASK_COMMENT_PAGE_MODEL_TYPE);
assertThat(getTaskCommentsBeforeDeletionResponse.getBody().getContent()).hasSize(2);
assertThat(getTaskCommentsBeforeDeleteionResponse.getBody()).isNotNull();
assertThat(getTaskCommentsBeforeDeleteionResponse.getBody().getContent()).hasSize(2);
String url =
restHelper.toUrl(Mapping.URL_TASK_COMMENT, "TCI:000000000000000000000000000000000004");
ThrowingCallable httpCall =
() -> {
template.exchange(
url,
HttpMethod.DELETE,
new HttpEntity<String>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
url,
HttpMethod.DELETE,
new HttpEntity<String>(restHelper.getHeadersUser_1_2()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.isInstanceOf(HttpClientErrorException.class)
.hasMessageContaining("TaskComment creator and current user must match.")
@ -359,13 +350,12 @@ class TaskCommentControllerIntTest {
String url = restHelper.toUrl(Mapping.URL_TASK_COMMENT, "NotExistingTaskComment");
ThrowingCallable httpCall =
() -> {
template.exchange(
url,
HttpMethod.DELETE,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
};
() ->
TEMPLATE.exchange(
url,
HttpMethod.DELETE,
new HttpEntity<String>(restHelper.getHeadersAdmin()),
ParameterizedTypeReference.forType(TaskCommentRepresentationModel.class));
assertThatThrownBy(httpCall)
.extracting(ex -> ((HttpClientErrorException) ex).getStatusCode())
.isEqualTo(HttpStatus.NOT_FOUND);

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

@ -6,7 +6,6 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static pro.taskana.common.rest.RestHelper.TEMPLATE;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
@ -54,13 +53,16 @@ class TaskControllerIntTest {
private final RestHelper restHelper;
private final DataSource dataSource;
@Value("${taskana.schemaName:TASKANA}")
public String schemaName;
private final String schemaName;
@Autowired
TaskControllerIntTest(RestHelper restHelper, DataSource dataSource) {
TaskControllerIntTest(
RestHelper restHelper,
DataSource dataSource,
@Value("${taskana.schemaName:TASKANA}") String schemaName) {
this.restHelper = restHelper;
this.dataSource = dataSource;
this.schemaName = schemaName;
}
@BeforeAll
@ -611,7 +613,7 @@ class TaskControllerIntTest {
}
@Test
void testCreateTaskWithInvalidParameter() throws IOException {
void testCreateTaskWithInvalidParameter() throws Exception {
final String taskToCreateJson =
"{\"classificationKey\":\"L11010\","
+ "\"workbasketSummaryResource\":"

9
rest/taskana-rest-spring/src/test/java/pro/taskana/task/rest/assembler/TaskRepresentationModelAssemberTest.java
View File

@ -12,7 +12,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.classification.rest.models.ClassificationSummaryRepresentationModel;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.rest.Mapping;
import pro.taskana.common.rest.TaskanaSpringBootTest;
import pro.taskana.task.api.TaskService;
@ -51,8 +50,7 @@ class TaskRepresentationModelAssemberTest {
}
@Test
void should_ReturnEntity_When_ConvertingRepresentationModelToEntity()
throws InvalidArgumentException {
void should_ReturnEntity_When_ConvertingRepresentationModelToEntity() throws Exception {
// given
ObjectReference primaryObjRef = new ObjectReference();
primaryObjRef.setId("abc");
@ -119,7 +117,7 @@ class TaskRepresentationModelAssemberTest {
@Test
void should_ReturnRepresentationModel_When_ConvertingEntityToRepresentationModel()
throws InvalidArgumentException {
throws Exception {
// given
ObjectReference primaryObjRef = new ObjectReference();
primaryObjRef.setId("abc");
@ -239,8 +237,7 @@ class TaskRepresentationModelAssemberTest {
assertThat(task).hasNoNullFieldsOrProperties().isNotSameAs(task2).isEqualTo(task2);
}
private void testEquality(Task task, TaskRepresentationModel repModel)
throws InvalidArgumentException {
private void testEquality(Task task, TaskRepresentationModel repModel) throws Exception {
TaskSummaryRepresentationModelAssemblerTest.testEquality(task, repModel);
testEqualityCustomAttributes(task.getCustomAttributes(), repModel.getCustomAttributes());

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