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

TSK-1227: made ObjectReference#System, Objectreference#SystemInstance optional, allow null in database

This commit is contained in:
sfrevel 2020-05-13 13:00:31 +02:00
parent 9dc3cc68e8
commit 5588d72691
9 changed files with 130 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -36,13 +36,6 @@ public class ObjectReference {
} else if (objectReference.getCompany() == null || objectReference.getCompany().length() == 0) {
throw new InvalidArgumentException(
String.format("Company of %s of %s must not be empty", objRefType, objName));
} else if (objectReference.getSystem() == null || objectReference.getSystem().length() == 0) {
throw new InvalidArgumentException(
String.format("System of %s of %s must not be empty", objRefType, objName));
} else if (objectReference.getSystemInstance() == null
|| objectReference.getSystemInstance().length() == 0) {
throw new InvalidArgumentException(
String.format("SystemInstance of %s of %s must not be empty", objRefType, objName));
} else if (objectReference.getType() == null || objectReference.getType().length() == 0) {
throw new InvalidArgumentException(
String.format("Type of %s of %s must not be empty", objRefType, objName));

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

@ -85,8 +85,8 @@ CREATE TABLE TASK (
PARENT_BUSINESS_PROCESS_ID VARCHAR(128) NULL,
OWNER VARCHAR(32) NULL,
POR_COMPANY VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32) NOT NULL,
POR_INSTANCE VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32),
POR_INSTANCE VARCHAR(32),
POR_TYPE VARCHAR(32) NOT NULL,
POR_VALUE VARCHAR(128) NOT NULL,
IS_READ SMALLINT NOT NULL,
@ -152,8 +152,8 @@ CREATE TABLE WORKBASKET_ACCESS_LIST(
CREATE TABLE OBJECT_REFERENCE(
ID VARCHAR(40) NOT NULL,
COMPANY VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32) NOT NULL,
SYSTEM_INSTANCE VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32),
SYSTEM_INSTANCE VARCHAR(32),
TYPE VARCHAR(32) NOT NULL,
VALUE VARCHAR(128) NOT NULL
);

10
lib/taskana-core/src/main/resources/sql/db2/taskana_schema_update_2.0.2_to_3.0.0_db2.sql
View File

@ -54,3 +54,13 @@ REORG TABLE TASK_COMMENT;
CREATE TABLE CONFIGURATION (
ENFORCE_SECURITY BOOLEAN NOT NULL
);
-- TSK-1227 allow null values in OBJECT_REFERENCE#SYSTEM and OBJECT_REFERENCE#SYSTEM_INSTANCE
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM DROP NOT NULL;
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM_INSTANCE DROP NOT NULL;
REORG TABLE OBJECT_REFERENCE;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM DROP NOT NULL;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM_INSTANCE DROP NOT NULL;
REORG TABLE TASK;

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

@ -92,8 +92,8 @@ CREATE TABLE TASK (
PARENT_BUSINESS_PROCESS_ID VARCHAR(128) NULL,
OWNER VARCHAR(32) NULL,
POR_COMPANY VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32) NOT NULL,
POR_INSTANCE VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32),
POR_INSTANCE VARCHAR(32),
POR_TYPE VARCHAR(32) NOT NULL,
POR_VALUE VARCHAR(128) NOT NULL,
IS_READ SMALLINT NOT NULL,
@ -159,8 +159,8 @@ CREATE TABLE WORKBASKET_ACCESS_LIST(
CREATE TABLE OBJECT_REFERENCE(
ID VARCHAR(40) NOT NULL,
COMPANY VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32) NOT NULL,
SYSTEM_INSTANCE VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32),
SYSTEM_INSTANCE VARCHAR(32),
TYPE VARCHAR(32) NOT NULL,
VALUE VARCHAR(128) NOT NULL
);

9
lib/taskana-core/src/main/resources/sql/h2/taskana_schema_update_2.0.2_to_3.0.0_h2.sql
View File

@ -39,3 +39,12 @@ ALTER TABLE TASK_COMMENT ALTER COLUMN TASK_ID VARCHAR(40);
CREATE TABLE CONFIGURATION (
ENFORCE_SECURITY BOOLEAN NOT NULL
);
-- TSK-1227 allow null values in OBJECT_REFERENCE#SYSTEM and OBJECT_REFERENCE#SYSTEM_INSTANCE
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM DROP NOT NULL;
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM_INSTANCE DROP NOT NULL;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM DROP NOT NULL;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM_INSTANCE DROP NOT NULL;

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

@ -87,8 +87,8 @@ CREATE TABLE TASK (
PARENT_BUSINESS_PROCESS_ID VARCHAR(128) NULL,
OWNER VARCHAR(32) NULL,
POR_COMPANY VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32) NOT NULL,
POR_INSTANCE VARCHAR(32) NOT NULL,
POR_SYSTEM VARCHAR(32),
POR_INSTANCE VARCHAR(32),
POR_TYPE VARCHAR(32) NOT NULL,
POR_VALUE VARCHAR(128) NOT NULL,
IS_READ BOOLEAN NOT NULL,
@ -154,8 +154,8 @@ CREATE TABLE WORKBASKET_ACCESS_LIST(
CREATE TABLE OBJECT_REFERENCE(
ID VARCHAR(40) NOT NULL,
COMPANY VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32) NOT NULL,
SYSTEM_INSTANCE VARCHAR(32) NOT NULL,
SYSTEM VARCHAR(32),
SYSTEM_INSTANCE VARCHAR(32),
TYPE VARCHAR(32) NOT NULL,
VALUE VARCHAR(128) NOT NULL
);

9
lib/taskana-core/src/main/resources/sql/postgres/taskana_schema_update_2.0.2_to_3.0.0_postgres.sql
View File

@ -39,3 +39,12 @@ ALTER TABLE TASK_COMMENT ALTER COLUMN TASK_ID TYPE VARCHAR(40);
CREATE TABLE CONFIGURATION (
ENFORCE_SECURITY BOOLEAN NOT NULL
);
-- TSK-1227 allow null values in OBJECT_REFERENCE#SYSTEM and OBJECT_REFERENCE#SYSTEM_INSTANCE
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM SET NULL;
ALTER TABLE OBJECT_REFERENCE ALTER COLUMN SYSTEM_INSTANCE SET NULL;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM SET NULL;
ALTER TABLE TASK ALTER COLUMN POR_SYSTEM_INSTANCE SET NULL;

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

@ -48,9 +48,7 @@ import pro.taskana.workbasket.api.models.Workbasket;
// import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
/**
* Acceptance test for all "create task" scenarios.
*/
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
class CreateTaskAccTest extends AbstractAccTest {
@ -82,7 +80,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateSimpleManualTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -112,12 +110,32 @@ class CreateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.isTransferred()).isFalse();
}
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_createTask_When_ObjectReferenceSystemAndSystemInstanceIsNull()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
String currentUser = CurrentUserContext.getUserid();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
ObjectReference objectReference =
createObjectReference("COMPANY_A", null, null, "VNR", "1234567");
newTask.setPrimaryObjRef(objectReference);
newTask.setOwner(currentUser);
Task createdTask = taskService.createTask(newTask);
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
}
@WithAccessId(user = "admin")
@WithAccessId(user = "taskadmin")
@TestTemplate
void should_CreateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
NotAuthorizedException, ClassificationNotFoundException {
NotAuthorizedException, ClassificationNotFoundException {
String currentUser = CurrentUserContext.getUserid();
@ -137,7 +155,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateTaskWithPlanned()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
Instant instantPlanned = Instant.now().plus(2, ChronoUnit.HOURS);
@ -214,7 +232,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testIdempotencyOfTaskCreation()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setExternalId("MyExternalId");
@ -258,8 +276,8 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateSimpleTaskWithCustomAttributes()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -325,8 +343,8 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateExternalTaskWithAttachment()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException,
NoSuchFieldException, IllegalAccessException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
@ -411,7 +429,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateExternalTaskWithMultipleAttachments()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010");
@ -463,7 +481,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCalculationOfDueDateAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
// SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
@ -496,7 +514,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCalculationOfPlannedDateAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
// SL P16D
Classification classification = classificationService.getClassification("L110105", "DOMAIN_A");
@ -531,7 +549,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testPrioDurationOfTaskFromAttachmentsAtCreate()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("L12010"); // prio 8, SL P7D
@ -632,32 +650,6 @@ class CreateTaskAccTest extends AbstractAccTest {
"2018-01-15",
createSimpleCustomProperties(3)));
testCreateTask.accept(
createAttachment(
"DOCTYPE_DEFAULT",
createObjectReference(
"COMPANY_A",
"SYSTEM_B",
null,
"ArchiveId",
"12345678901234567890123456789012345678901234567890"),
"E-MAIL",
"2018-01-15",
createSimpleCustomProperties(3)));
testCreateTask.accept(
createAttachment(
"DOCTYPE_DEFAULT",
createObjectReference(
"COMPANY_A",
null,
"INSTANCE_B",
"ArchiveId",
"12345678901234567890123456789012345678901234567890"),
"E-MAIL",
"2018-01-15",
createSimpleCustomProperties(3)));
testCreateTask.accept(
createAttachment(
"DOCTYPE_DEFAULT",
@ -676,7 +668,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testUseCustomNameIfSetForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -694,7 +686,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testUseClassificationMetadataFromCorrectDomainForNewTask()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -766,8 +758,10 @@ class CreateTaskAccTest extends AbstractAccTest {
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null));
testCreateTask.accept(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
testCreateTask.accept(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR", "1234567"));
testCreateTask.accept(createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR", "1234567"));
// testCreateTask.accept(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR",
// "1234567"));
// testCreateTask.accept(createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR",
// "1234567"));
testCreateTask.accept(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
}
@ -775,7 +769,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testSetDomainFromWorkbasket()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketNotFoundException, TaskAlreadyExistException {
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@ -797,7 +791,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreatedTaskObjectEqualsReadTaskObject()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
WorkbasketNotFoundException, TaskAlreadyExistException, TaskNotFoundException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -831,7 +825,7 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateSimpleTaskWithCallbackInfo()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
@ -909,8 +903,8 @@ class CreateTaskAccTest extends AbstractAccTest {
@Test
void testCreateTaskWithWorkbasketMarkedForDeletion()
throws NotAuthorizedException, InvalidStateException, TaskNotFoundException,
TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
ClassificationNotFoundException, WorkbasketInUseException {
TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
ClassificationNotFoundException, WorkbasketInUseException {
String wbId = "WBI:100000000000000000000000000000000008";
Task taskToPreventWorkbasketDeletion = taskService.newTask(wbId);

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

@ -34,9 +34,7 @@ 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.
*/
/** Acceptance test for all "update task" scenarios. */
@ExtendWith(JaasExtension.class)
class UpdateTaskAccTest extends AbstractAccTest {
@ -48,8 +46,8 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_UpdatePrimaryObjectReferenceOfTask_When_Requested()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -73,6 +71,36 @@ class UpdateTaskAccTest extends AbstractAccTest {
assertThat(updatedTask.getParentBusinessProcessId()).isEqualTo("MY_PARENT_PROCESS_ID");
}
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_UpdatePrimaryObjectReferenceOfTask_When_ObjectreferenceSystemAndSystemInstanceIsNull()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Instant modifiedOriginal = task.getModified();
task.setPrimaryObjRef(createObjectReference("COMPANY_A", null, null, "VNR", "7654321"));
task.setBusinessProcessId("MY_PROCESS_ID");
task.setParentBusinessProcessId("MY_PARENT_PROCESS_ID");
Task updatedTask = taskService.updateTask(task);
updatedTask = taskService.getTask(updatedTask.getId());
assertThat(updatedTask).isNotNull();
assertThat(updatedTask.getPrimaryObjRef().getValue()).isEqualTo("7654321");
assertThat(updatedTask.getPrimaryObjRef().getSystem()).isNull();
assertThat(updatedTask.getPrimaryObjRef().getSystemInstance()).isNull();
assertThat(updatedTask.getCreated()).isNotNull();
assertThat(updatedTask.getModified()).isNotNull();
assertThat(modifiedOriginal.isAfter(updatedTask.getModified())).isFalse();
assertThat(updatedTask.getModified()).isNotEqualTo(updatedTask.getCreated());
assertThat(updatedTask.getCreated()).isEqualTo(task.getCreated());
assertThat(updatedTask.isRead()).isEqualTo(task.isRead());
assertThat(updatedTask.getBusinessProcessId()).isEqualTo("MY_PROCESS_ID");
assertThat(updatedTask.getParentBusinessProcessId()).isEqualTo("MY_PARENT_PROCESS_ID");
}
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_ThrowException_When_MandatoryPrimaryObjectReferenceIsNotSetOrIncomplete()
@ -97,28 +125,17 @@ class UpdateTaskAccTest extends AbstractAccTest {
.isInstanceOf(InvalidArgumentException.class);
Task task3 = taskService.getTask("TKI:000000000000000000000000000000000000");
task3.setPrimaryObjRef(createObjectReference("COMPANY_A", "SYSTEM_A", null, "VNR", "1234567"));
task3.setPrimaryObjRef(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
assertThatThrownBy(() -> taskService.updateTask(task3))
.isInstanceOf(InvalidArgumentException.class);
Task task4 = taskService.getTask("TKI:000000000000000000000000000000000000");
task4.setPrimaryObjRef(
createObjectReference("COMPANY_A", null, "INSTANCE_A", "VNR", "1234567"));
assertThatThrownBy(() -> taskService.updateTask(task4))
.isInstanceOf(InvalidArgumentException.class);
Task task5 = taskService.getTask("TKI:000000000000000000000000000000000000");
task5.setPrimaryObjRef(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
assertThatThrownBy(() -> taskService.updateTask(task5))
.isInstanceOf(InvalidArgumentException.class);
}
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_ThrowException_When_TaskHasAlreadyBeenUpdated()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException, InterruptedException {
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException, InterruptedException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -144,19 +161,19 @@ class UpdateTaskAccTest extends AbstractAccTest {
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final ClassificationSummary classificationSummary = task.getClassificationSummary();
task.setClassificationKey("T2100");
ThrowingCallable updateTaskCall = () -> {
taskService.updateTask(task);
};
ThrowingCallable updateTaskCall =
() -> {
taskService.updateTask(task);
};
assertThatCode(updateTaskCall).doesNotThrowAnyException();
}
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_UpdateTaskProperties_When_ClassificationOfTaskIsChanged()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException, SQLException {
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException, SQLException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -201,8 +218,8 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_UpdateTask_When_CustomPropertiesOfTaskWereChanged()
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setCustomAttribute("1", "T2100");
@ -306,8 +323,8 @@ class UpdateTaskAccTest extends AbstractAccTest {
@Test
void should_UpdateCallbackInfo_When_RequestedByApi()
throws WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
ConcurrencyException, AttachmentPersistenceException, InvalidStateException {
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
ConcurrencyException, AttachmentPersistenceException, InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");