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

TSK-864: Expected exception handling for unit tests

This commit is contained in:
Benjamin Eckstein 2019-11-13 10:49:57 +01:00 committed by Holger Hagen
parent 605d681c77
commit c81de3d08b
11 changed files with 130 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -3,7 +3,6 @@ package acceptance.classification;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@ -80,14 +79,9 @@ public class DeleteClassificationAccTest extends AbstractAccTest {
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationInUseException {
classificationService.deleteClassification("L3060", "");
boolean classificationNotFound = false;
try {
classificationService.getClassification("L3060", "DOMAIN_A");
} catch (ClassificationNotFoundException e) {
classificationNotFound = true;
}
assertTrue(classificationNotFound);
Assertions.assertThrows(ClassificationNotFoundException.class, () ->
classificationService.getClassification("L3060", "DOMAIN_A")
);
}
@WithAccessId(
@ -104,26 +98,19 @@ public class DeleteClassificationAccTest extends AbstractAccTest {
groupNames = {"group_1", "businessadmin"})
@Test
public void testThrowExceptionWhenChildClassificationIsInUseAndRollback()
throws NotAuthorizedException, ClassificationNotFoundException {
boolean classificationInUse = false;
try {
classificationService.deleteClassification("L11010", "DOMAIN_A");
} catch (ClassificationInUseException e) {
classificationInUse = true;
}
throws ClassificationNotFoundException {
Assertions.assertThrows(ClassificationInUseException.class, () ->
classificationService.deleteClassification("L11010", "DOMAIN_A"));
Classification rollback = classificationService.getClassification("L11010", "DOMAIN_A");
assertTrue(classificationInUse);
assertEquals("DOMAIN_A", rollback.getDomain());
classificationInUse = false;
try {
classificationService.deleteClassification("L11010", "");
} catch (ClassificationInUseException e) {
classificationInUse = true;
}
Assertions.assertThrows(ClassificationInUseException.class, () ->
classificationService.deleteClassification("L11010", ""));
Classification rollbackMaster = classificationService.getClassification("L11010", "");
Classification rollbackA = classificationService.getClassification("L11010", "DOMAIN_A");
assertTrue(classificationInUse);
assertEquals(rollbackMaster.getKey(), rollbackA.getKey());
assertNotEquals(rollbackMaster.getDomain(), rollbackA.getDomain());
}

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

@ -124,8 +124,6 @@ public class TaskanaConfigAccTest extends TaskanaEngineImpl {
writer.println("taskana.classification.categories.task= EXTERNAL, manual, autoMAtic, Process");
writer.println("taskana.classification.categories.document= EXTERNAL");
}
} catch (IOException e) {
throw e;
}
}
return propertiesFileName;

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

@ -118,8 +118,6 @@ public class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
writer.println("taskana.roles.Admin =hOlGeR " + delimiter + "name=Stefan,Organisation=novatec");
writer.println(" taskana.roles.businessadmin = name=ebe, ou = bpm " + delimiter + " konstantin ");
writer.println(" taskana.roles.user = ");
} catch (IOException e) {
throw e;
}
}
return propertiesFileName;
@ -142,8 +140,6 @@ public class TaskanaRoleConfigAccTest extends TaskanaEngineImpl {
writer.println("taskana.roles.Admin =hOlGeR|Stefan");
writer.println(" taskana.roles.businessadmin = ebe | konstantin ");
writer.println(" taskana.roles.user = nobody");
} catch (IOException e) {
throw e;
}
}
return propertiesFileName;

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

@ -3,6 +3,7 @@ package acceptance.security;
import java.util.List;
import org.junit.Assert;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -32,17 +33,11 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
.nameLike("%")
.list();
Assert.assertEquals(0L, results.size());
try {
results = workbasketService.createWorkbasketQuery()
Assertions.assertThrows(NotAuthorizedException.class, () ->
workbasketService.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
Assert.fail("NotAuthrorizedException was expected");
} catch (NotAuthorizedException ex) {
}
.list());
}
@WithAccessId(
@ -55,16 +50,11 @@ public class WorkbasketQueryAccTest extends AbstractAccTest {
.list();
Assert.assertEquals(0L, results.size());
try {
results = workbasketService.createWorkbasketQuery()
Assertions.assertThrows(NotAuthorizedException.class, () ->
workbasketService.createWorkbasketQuery()
.nameLike("%")
.accessIdsHavePermission(WorkbasketPermission.TRANSFER, "teamlead_1", "group_1", "group_2")
.list();
Assert.fail("NotAuthrorizedException was expected");
} catch (NotAuthorizedException ex) {
}
.list());
}
@WithAccessId(

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

@ -8,7 +8,6 @@ import static org.junit.Assert.assertTrue;
import java.time.Instant;
import org.junit.Assert;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@ -130,29 +129,18 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void testCompleteTaskThrowsErrors() {
TaskService taskService = taskanaEngine.getTaskService();
try {
taskService.completeTask("TKI:0000000000000000000000000000000000xx");
} catch (Exception e) {
Assert.assertEquals(TaskNotFoundException.class, e.getClass());
}
try {
taskService.completeTask("TKI:000000000000000000000000000000000004");
} catch (Exception e) {
Assert.assertEquals(NotAuthorizedException.class, e.getClass());
}
Assertions.assertThrows(TaskNotFoundException.class, () ->
taskService.completeTask("TKI:0000000000000000000000000000000000xx"));
try {
taskService.completeTask("TKI:000000000000000000000000000000000025");
} catch (Exception e) {
Assert.assertEquals(InvalidStateException.class, e.getClass());
}
Assertions.assertThrows(NotAuthorizedException.class, () ->
taskService.completeTask("TKI:000000000000000000000000000000000004"));
try {
taskService.completeTask("TKI:000000000000000000000000000000000026");
} catch (Exception e) {
Assert.assertEquals(InvalidOwnerException.class, e.getClass());
}
Assertions.assertThrows(InvalidStateException.class, () ->
taskService.completeTask("TKI:000000000000000000000000000000000025"));
Assertions.assertThrows(InvalidOwnerException.class, () ->
taskService.completeTask("TKI:000000000000000000000000000000000027"));
}
@WithAccessId(
@ -290,7 +278,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
@Test
void testForceCancelClaimSuccessfull()
throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
NotAuthorizedException {
NotAuthorizedException, InterruptedException {
TaskService taskService = taskanaEngine.getTaskService();
Task taskBefore = taskService.getTask("TKI:000000000000000000000000000000000043");
@ -299,11 +287,7 @@ class CompleteTaskAccTest extends AbstractAccTest {
assertEquals(TaskState.CLAIMED, taskBefore.getState());
Instant before = Instant.now();
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread.sleep(1);
Task taskAfter = taskService.forceCancelClaim("TKI:000000000000000000000000000000000043");
assertNotNull(taskAfter);

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

@ -2,7 +2,6 @@ package acceptance.task;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.List;
@ -82,12 +81,11 @@ public class DeleteTaskAccTest extends AbstractAccTest {
throws TaskNotFoundException, InvalidStateException, NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
try {
taskService.deleteTask(task.getId());
fail("Should not be possible to delete claimed task without force flag");
} catch (InvalidStateException ex) {
taskService.forceDeleteTask(task.getId());
}
Assertions.assertThrows(InvalidStateException.class, () ->
taskService.deleteTask(task.getId()), "Should not be possible to delete claimed task without force flag");
taskService.forceDeleteTask(task.getId());
Assertions.assertThrows(TaskNotFoundException.class, () ->
taskService.getTask("TKI:000000000000000000000000000000000027"));

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

@ -5,6 +5,8 @@ import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static pro.taskana.BaseQuery.SortDirection.ASCENDING;
import static pro.taskana.BaseQuery.SortDirection.DESCENDING;
import static pro.taskana.TaskQueryColumnName.A_CHANNEL;
import static pro.taskana.TaskQueryColumnName.A_CLASSIFICATION_ID;
import static pro.taskana.TaskQueryColumnName.A_REF_VALUE;
@ -27,7 +29,6 @@ import org.junit.jupiter.api.extension.ExtendWith;
import acceptance.AbstractAccTest;
import pro.taskana.Attachment;
import pro.taskana.BaseQuery.SortDirection;
import pro.taskana.Task;
import pro.taskana.TaskQuery;
import pro.taskana.TaskQueryColumnName;
@ -54,13 +55,6 @@ import pro.taskana.security.WithAccessId;
@ExtendWith(JAASExtension.class)
class QueryTasksAccTest extends AbstractAccTest {
private static SortDirection asc = SortDirection.ASCENDING;
private static SortDirection desc = SortDirection.DESCENDING;
QueryTasksAccTest() {
super();
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"admin"})
@ -70,7 +64,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<String> notWorkingColumns = new ArrayList<>();
for (TaskQueryColumnName columnName : TaskQueryColumnName.values()) {
try {
taskService.createTaskQuery().listValues(columnName, asc);
taskService.createTaskQuery().listValues(columnName, ASCENDING);
} catch (PersistenceException p) {
notWorkingColumns.add(columnName.toString());
}
@ -86,7 +80,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<String> columnValueList = taskService.createTaskQuery()
.ownerLike("%user%")
.orderByOwner(desc)
.orderByOwner(DESCENDING)
.listValues(OWNER, null);
assertNotNull(columnValueList);
assertEquals(3, columnValueList.size());
@ -116,13 +110,13 @@ class QueryTasksAccTest extends AbstractAccTest {
assertEquals(6, columnValueList.size());
columnValueList = taskService.createTaskQuery()
.orderByAttachmentClassificationId(desc)
.orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null);
assertNotNull(columnValueList);
assertEquals(12, columnValueList.size());
columnValueList = taskService.createTaskQuery()
.orderByClassificationKey(desc)
.orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null);
assertNotNull(columnValueList);
assertEquals(7, columnValueList.size());
@ -137,7 +131,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.ownerLike("%a%", "%u%")
.orderByCreated(asc)
.orderByCreated(ASCENDING)
.list();
assertThat(results.size(), equalTo(25));
@ -167,8 +161,7 @@ class QueryTasksAccTest extends AbstractAccTest {
String[] parentIds = results.stream()
.map(TaskSummary::getParentBusinessProcessId)
.collect(Collectors.toList())
.toArray(new String[0]);
.toArray(String[]::new);
List<TaskSummary> result2 = taskService.createTaskQuery()
.parentBusinessProcessIdIn(parentIds)
@ -272,7 +265,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<String> resultValues = taskService.createTaskQuery()
.externalIdLike("ETI:000000000000000000000000000000%")
.listValues(TaskQueryColumnName.EXTERNAL_ID, desc);
.listValues(TaskQueryColumnName.EXTERNAL_ID, DESCENDING);
assertThat(resultValues.size(), equalTo(70));
long countAllExternalIds = taskService.createTaskQuery()
@ -892,15 +885,15 @@ class QueryTasksAccTest extends AbstractAccTest {
long numberOfTasks = taskQuery.count();
assertEquals(25, numberOfTasks);
List<TaskSummary> tasks = taskQuery
.orderByDue(SortDirection.DESCENDING)
.orderByDue(DESCENDING)
.list();
assertEquals(25, tasks.size());
List<TaskSummary> tasksp = taskQuery
.orderByDue(SortDirection.DESCENDING)
.orderByDue(DESCENDING)
.listPage(4, 5);
assertEquals(5, tasksp.size());
tasksp = taskQuery
.orderByDue(SortDirection.DESCENDING)
.orderByDue(DESCENDING)
.listPage(5, 5);
assertEquals(5, tasksp.size());
}
@ -1120,7 +1113,7 @@ class QueryTasksAccTest extends AbstractAccTest {
getInstant("2018-01-31T12:00:00"));
List<TaskSummary> results = taskService.createTaskQuery()
.attachmentReceivedWithin(interval)
.orderByWorkbasketId(desc)
.orderByWorkbasketId(DESCENDING)
.list();
assertEquals(2, results.size());
assertEquals("TKI:000000000000000000000000000000000001", results.get(0).getTaskId());
@ -1133,7 +1126,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForOrderByCreatorDesc() {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.orderByCreator(desc)
.orderByCreator(DESCENDING)
.list();
assertEquals("user_1_1", results.get(0).getCreator());
}
@ -1144,7 +1137,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForOrderByWorkbasketIdDesc() {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.orderByWorkbasketId(desc)
.orderByWorkbasketId(DESCENDING)
.list();
assertEquals("WBI:100000000000000000000000000000000015",
results.get(0).getWorkbasketSummary().getId());
@ -1157,7 +1150,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("1", "%")
.orderByCustomAttribute("1", asc)
.orderByCustomAttribute("1", ASCENDING)
.list();
assertEquals("custom1", results.get(0).getCustomAttribute("1"));
}
@ -1169,7 +1162,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("2", "%")
.orderByCustomAttribute("2", desc)
.orderByCustomAttribute("2", DESCENDING)
.list();
assertEquals("custom2", results.get(0).getCustomAttribute("2"));
}
@ -1181,7 +1174,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("3", "%")
.orderByCustomAttribute("3", asc)
.orderByCustomAttribute("3", ASCENDING)
.list();
assertEquals("custom3", results.get(0).getCustomAttribute("3"));
}
@ -1193,7 +1186,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("4", "%")
.orderByCustomAttribute("4", desc)
.orderByCustomAttribute("4", DESCENDING)
.list();
assertEquals("rty",
@ -1207,7 +1200,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("5", "%")
.orderByCustomAttribute("5", asc)
.orderByCustomAttribute("5", ASCENDING)
.list();
assertEquals("al", results.get(0).getCustomAttribute("5"));
}
@ -1219,7 +1212,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("6", "%")
.orderByCustomAttribute("6", desc)
.orderByCustomAttribute("6", DESCENDING)
.list();
assertEquals("vvg", results.get(0).getCustomAttribute("6"));
}
@ -1230,7 +1223,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForOrderByCustom7Asc() throws InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.orderByCustomAttribute("7", asc)
.orderByCustomAttribute("7", ASCENDING)
.customAttributeLike("7", "%")
.list();
assertEquals("custom7", results.get(0).getCustomAttribute("7"));
@ -1242,7 +1235,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForOrderByCustom8Desc() throws InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.orderByCustomAttribute("8", desc)
.orderByCustomAttribute("8", DESCENDING)
.customAttributeLike("8", "%")
.list();
assertEquals("lnp", results.get(0).getCustomAttribute("8"));
@ -1255,7 +1248,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("9", "%")
.orderByCustomAttribute("9", asc)
.orderByCustomAttribute("9", ASCENDING)
.list();
assertEquals("bbq", results.get(0).getCustomAttribute("9"));
}
@ -1267,7 +1260,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("10", "%")
.orderByCustomAttribute("10", desc)
.orderByCustomAttribute("10", DESCENDING)
.list();
assertEquals("ert", results.get(0).getCustomAttribute("10"));
}
@ -1278,7 +1271,7 @@ class QueryTasksAccTest extends AbstractAccTest {
void testQueryForOrderByCustom11Desc() throws InvalidArgumentException {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.orderByCustomAttribute("11", desc)
.orderByCustomAttribute("11", DESCENDING)
.customAttributeLike("11", "%")
.list();
@ -1294,7 +1287,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("12", "%")
.orderByCustomAttribute("12", asc)
.orderByCustomAttribute("12", ASCENDING)
.list();
assertEquals("custom12", results.get(0).getCustomAttribute("12"));
}
@ -1306,7 +1299,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("13", "%")
.orderByCustomAttribute("13", desc)
.orderByCustomAttribute("13", DESCENDING)
.list();
assertEquals("ert",
@ -1320,7 +1313,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("14", "%")
.orderByCustomAttribute("14", asc)
.orderByCustomAttribute("14", ASCENDING)
.list();
assertEquals("abc", results.get(0).getCustomAttribute("14"));
}
@ -1332,7 +1325,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("15", "%")
.orderByCustomAttribute("15", desc)
.orderByCustomAttribute("15", DESCENDING)
.list();
assertEquals("ert",
@ -1346,7 +1339,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.customAttributeLike("16", "%")
.orderByCustomAttribute("16", asc)
.orderByCustomAttribute("16", ASCENDING)
.list();
assertEquals("custom16", results.get(0).getCustomAttribute("16"));
}
@ -1370,7 +1363,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentClassificationId(asc)
.orderByAttachmentClassificationId(ASCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000011", results.get(0).getTaskId());
assertEquals("TKI:000000000000000000000000000000000010", results.get(results.size() - 1).getTaskId());
@ -1384,7 +1377,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentClassificationId(desc)
.orderByAttachmentClassificationId(DESCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000010", results.get(0).getTaskId());
assertEquals("TKI:000000000000000000000000000000000011", results.get(results.size() - 1).getTaskId());
@ -1399,7 +1392,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentClassificationKey(asc)
.orderByAttachmentClassificationKey(ASCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000010", results.get(0).getTaskId());
@ -1415,7 +1408,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentClassificationKey(desc)
.orderByAttachmentClassificationKey(DESCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000012", results.get(0).getTaskId());
@ -1431,7 +1424,7 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentReference(desc)
.orderByAttachmentReference(DESCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000012", results.get(0).getTaskId());
@ -1447,8 +1440,8 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> results = taskService.createTaskQuery()
.idIn("TKI:000000000000000000000000000000000010", "TKI:000000000000000000000000000000000011",
"TKI:000000000000000000000000000000000012")
.orderByAttachmentChannel(asc)
.orderByAttachmentReference(desc)
.orderByAttachmentChannel(ASCENDING)
.orderByAttachmentReference(DESCENDING)
.list();
assertEquals("TKI:000000000000000000000000000000000012", results.get(0).getTaskId());
@ -1463,7 +1456,7 @@ class QueryTasksAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
List<TaskSummary> results = taskService.createTaskQuery()
.attachmentChannelLike("CH%")
.orderByClassificationKey(desc)
.orderByClassificationKey(DESCENDING)
.list();
assertEquals("T2000", results.get(0).getClassificationSummary().getKey());
@ -1471,7 +1464,7 @@ class QueryTasksAccTest extends AbstractAccTest {
results = taskService.createTaskQuery()
.attachmentChannelLike("CH%")
.orderByClassificationKey(asc)
.orderByClassificationKey(ASCENDING)
.list();
assertEquals("L1050", results.get(0).getClassificationSummary().getKey());

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

@ -309,21 +309,15 @@ public class TransferTaskAccTest extends AbstractAccTest {
public void testTransferTasksWithInvalidTasksIdList() throws NotAuthorizedException, WorkbasketNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
// test with invalid list
try {
taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
Assert.fail("exception was excepted to be thrown");
} catch (InvalidArgumentException e) {
Assert.assertEquals(e.getMessage(), "TaskIds must not be null.");
}
Throwable t = Assertions.assertThrows(InvalidArgumentException.class, () ->
taskService.transferTasks("WBI:100000000000000000000000000000000006", null));
Assert.assertEquals(t.getMessage(), "TaskIds must not be null.");
// test with list containing only invalid arguments
try {
List<String> taskIds = Arrays.asList("", "", "", null);
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
Assert.fail("exception was excepted to be thrown");
} catch (InvalidArgumentException e) {
Assert.assertEquals(e.getMessage(), "TaskIds must not contain only invalid arguments.");
}
Throwable t2 = Assertions.assertThrows(InvalidArgumentException.class, () ->
taskService.transferTasks("WBI:100000000000000000000000000000000006", Arrays.asList("", "", "", null)));
Assert.assertEquals(t2.getMessage(), "TaskIds must not contain only invalid arguments.");
}
@WithAccessId(

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

@ -9,7 +9,6 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.time.Instant;
import java.util.Arrays;
@ -89,49 +88,23 @@ public class UpdateTaskAccTest extends AbstractAccTest {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setPrimaryObjRef(null);
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
task.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null));
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
task.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
task.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR", "1234567"));
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
task.setPrimaryObjRef(createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR", "1234567"));
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
task.setPrimaryObjRef(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
try {
taskService.updateTask(task);
fail("update() should have thrown InvalidArgumentException.");
} catch (InvalidArgumentException ex) {
// nothing to do
}
Assertions.assertThrows(InvalidArgumentException.class, () -> taskService.updateTask(task));
}
@WithAccessId(
@ -152,11 +125,8 @@ public class UpdateTaskAccTest extends AbstractAccTest {
updatedTask = taskService.getTask(updatedTask.getId());
task2.setCustomAttribute("2", "Walter");
try {
updatedTask = taskService.updateTask(task2);
} catch (ConcurrencyException ex) {
assertEquals("The task has already been updated by another user", ex.getMessage());
}
Assertions.assertThrows(ConcurrencyException.class, () -> taskService.updateTask(task2),
"The task has already been updated by another user");
}
@ -205,11 +175,7 @@ public class UpdateTaskAccTest extends AbstractAccTest {
assertFalse(updatedTask2.isRead());
assertFalse(updatedTask2.getModified().isBefore(updatedTask.getModified()));
try {
taskService.setTaskRead("INVALID", true);
fail("TaskNotFoundException should have been thrown.");
} catch (TaskNotFoundException e) {
}
Assertions.assertThrows(TaskNotFoundException.class, () -> taskService.setTaskRead("INVALID", true));
}
@WithAccessId(

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

@ -3,7 +3,6 @@ package acceptance.workbasket;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.List;
@ -110,59 +109,45 @@ public class CreateWorkbasketAccTest extends AbstractAccTest {
workbasket.setName("Megabasket");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // missing key
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
// missing key
Assertions.assertThrows(InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket));
workbasket = workbasketService.newWorkbasket("key", "novatec");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // missing name
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
Workbasket workbasket2 = workbasketService.newWorkbasket("key", "novatec");
workbasket2.setType(WorkbasketType.GROUP);
workbasket2.setOrgLevel1("company");
// missing name
Assertions.assertThrows(InvalidWorkbasketException.class,
() -> workbasketService.createWorkbasket(workbasket2));
workbasket = workbasketService.newWorkbasket("key", "novatec");
workbasket.setName("Megabasket");
workbasket.setOrgLevel1("company");
try { // missing type
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
Workbasket workbasket3 = workbasketService.newWorkbasket("key", "novatec");
workbasket3.setName("Megabasket");
workbasket3.setOrgLevel1("company");
// missing type
Assertions.assertThrows(InvalidWorkbasketException.class,
() -> workbasketService.createWorkbasket(workbasket3));
workbasket = workbasketService.newWorkbasket("key", null);
workbasket.setName("Megabasket");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // missing domain
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
Workbasket workbasket4 = workbasketService.newWorkbasket("key", null);
workbasket4.setName("Megabasket");
workbasket4.setType(WorkbasketType.GROUP);
workbasket4.setOrgLevel1("company");
// missing domain
Assertions.assertThrows(InvalidWorkbasketException.class,
() -> workbasketService.createWorkbasket(workbasket4));
workbasket = workbasketService.newWorkbasket("", "novatec");
workbasket.setName("Megabasket");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // empty key
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
Workbasket workbasket5 = workbasketService.newWorkbasket("", "novatec");
workbasket5.setName("Megabasket");
workbasket5.setType(WorkbasketType.GROUP);
workbasket5.setOrgLevel1("company");
// empty key
Assertions.assertThrows(InvalidWorkbasketException.class,
() -> workbasketService.createWorkbasket(workbasket5));
workbasket = workbasketService.newWorkbasket("key", "novatec");
workbasket.setName("");
workbasket.setType(WorkbasketType.GROUP);
workbasket.setOrgLevel1("company");
try { // empty name
workbasketService.createWorkbasket(workbasket);
fail("InvalidWorkbasketException was expected");
} catch (InvalidWorkbasketException e) {
}
Workbasket workbasket6 = workbasketService.newWorkbasket("key", "novatec");
workbasket6.setName("");
workbasket6.setType(WorkbasketType.GROUP);
workbasket6.setOrgLevel1("company");
// empty name
Assertions.assertThrows(InvalidWorkbasketException.class, () -> workbasketService.createWorkbasket(workbasket));
}
@WithAccessId(

2
lib/taskana-core/src/test/java/pro/taskana/security/JAASExtension.java
View File

@ -42,6 +42,8 @@ public class JAASExtension implements InvocationInterceptor {
try {
invocation.proceed();
} catch (Exception e) {
throw e;
} catch (Throwable e) {
throw new Exception(e);
}