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

TSK-1261: made tests more robust (for running on weekend)

This commit is contained in:
Mustapha Zorgati 2020-05-31 03:09:21 +02:00
parent da18e1c14c
commit cec65fbd01
5 changed files with 64 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lib/taskana-core/src/main/java/pro/taskana/common/internal/util/WorkingDaysToDaysConverter.java
View File

@ -32,11 +32,7 @@ public final class WorkingDaysToDaysConverter {
private static final long OFFSET_ASCENSION_DAY = 39; // Himmelfahrt
private static final long OFFSET_WHIT_MONDAY = 50; // Pfingstmontag
private static final long OFFSET_CORPUS_CHRISTI = 60; // Fronleichnam
private static boolean germanHolidaysEnabled;
private static boolean corpusChristiEnabled; // Fronleichnam
private static Set<CustomHoliday> customHolidays = new HashSet<>();
private static Set<CustomHoliday> germanHolidays =
private static final Set<CustomHoliday> GERMAN_HOLIDAYS =
new HashSet<>(
Arrays.asList(
CustomHoliday.of(1, 1), // new year
@ -45,6 +41,10 @@ public final class WorkingDaysToDaysConverter {
CustomHoliday.of(25, 12), // Christmas
CustomHoliday.of(26, 12) // Christmas
));
private static boolean germanHolidaysEnabled;
private static boolean corpusChristiEnabled; // Fronleichnam
private static Set<CustomHoliday> customHolidays = new HashSet<>();
private Instant referenceDate;
private LocalDate easterSunday;
@ -163,7 +163,7 @@ public final class WorkingDaysToDaysConverter {
}
public boolean isGermanHoliday(LocalDate date) {
if (germanHolidays.contains(CustomHoliday.of(date.getDayOfMonth(), date.getMonthValue()))) {
if (GERMAN_HOLIDAYS.contains(CustomHoliday.of(date.getDayOfMonth(), date.getMonthValue()))) {
return true;
}

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

@ -1,6 +1,7 @@
package acceptance;
import java.sql.SQLException;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
@ -8,8 +9,9 @@ import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import javax.sql.DataSource;
import org.junit.jupiter.api.BeforeAll;
@ -19,6 +21,7 @@ import pro.taskana.common.api.TaskanaEngine;
import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
import pro.taskana.common.api.TimeInterval;
import pro.taskana.common.internal.TaskanaEngineTestConfiguration;
import pro.taskana.common.internal.util.WorkingDaysToDaysConverter;
import pro.taskana.sampledata.SampleDataGenerator;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.ObjectReference;
@ -28,6 +31,12 @@ public abstract class AbstractAccTest {
protected static TaskanaEngineConfiguration taskanaEngineConfiguration;
protected static TaskanaEngine taskanaEngine;
protected static WorkingDaysToDaysConverter converter;
public AbstractAccTest() {
WorkingDaysToDaysConverter.setGermanPublicHolidaysEnabled(true);
converter = WorkingDaysToDaysConverter.initialize();
}
@BeforeAll
public static void setupTest() throws Exception {
@ -62,11 +71,9 @@ public abstract class AbstractAccTest {
}
protected Map<String, String> createSimpleCustomProperties(int propertiesCount) {
HashMap<String, String> properties = new HashMap<>();
for (int i = 1; i <= propertiesCount; i++) {
properties.put("Property_" + i, "Property Value of Property_" + i);
}
return properties;
return IntStream.rangeClosed(1, propertiesCount)
.mapToObj(String::valueOf)
.collect(Collectors.toMap("Property_"::concat, "Property Value of Property_"::concat));
}
protected Attachment createAttachment(
@ -114,4 +121,12 @@ public abstract class AbstractAccTest {
protected Instant getInstant(String datetime) {
return LocalDateTime.parse(datetime).atZone(ZoneId.of("UTC")).toInstant();
}
protected Instant moveForwardToWorkingDay(Instant date) {
return converter.addWorkingDaysToInstant(date, Duration.ZERO);
}
protected Instant moveBackToWorkingDay(Instant date) {
return converter.subtractWorkingDaysFromInstant(date, Duration.ZERO);
}
}

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

@ -5,18 +5,16 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import acceptance.AbstractAccTest;
import java.time.Duration;
import java.util.HashMap;
import java.time.Instant;
import java.util.Map;
import java.util.function.Consumer;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
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 pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
@ -24,7 +22,6 @@ import pro.taskana.common.internal.TaskanaEngineProxyForTest;
import pro.taskana.common.internal.security.CurrentUserContext;
import pro.taskana.common.internal.security.JaasExtension;
import pro.taskana.common.internal.security.WithAccessId;
import pro.taskana.common.internal.util.WorkingDaysToDaysConverter;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.exceptions.InvalidStateException;
@ -41,22 +38,11 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketInUseException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
// import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
/** Acceptance test for all "create task" scenarios. */
@ExtendWith(JaasExtension.class)
class CreateTaskAccTest extends AbstractAccTest {
private TaskService taskService;
private ClassificationService classificationService;
private WorkingDaysToDaysConverter converter;
@BeforeEach
void setup() {
taskService = taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
converter = WorkingDaysToDaysConverter.initialize();
}
private final TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
@ -86,6 +72,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(objectReference);
newTask.setOwner("user_1_1");
Task createdTask = taskService.createTask(newTask);
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
@ -99,7 +86,7 @@ class CreateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
@ -160,6 +147,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getCreator()).isEqualTo(CurrentUserContext.getUserid());
@ -172,7 +160,7 @@ class CreateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
@ -185,10 +173,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask2.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
ThrowingCallable call =
() -> {
taskService.createTask(newTask2);
};
ThrowingCallable call = () -> taskService.createTask(newTask2);
assertThatThrownBy(call).isInstanceOf(TaskAlreadyExistException.class);
}
@ -206,6 +191,7 @@ class CreateTaskAccTest extends AbstractAccTest {
Map<String, String> customAttributesForCreate = createSimpleCustomProperties(13);
newTask.setCustomAttributes(customAttributesForCreate);
Task createdTask = taskService.createTask(newTask);
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
@ -216,7 +202,7 @@ class CreateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
@ -462,13 +448,10 @@ class CreateTaskAccTest extends AbstractAccTest {
void testThrowsExceptionIfAttachmentIsInvalid() throws ClassificationNotFoundException {
Consumer<Attachment> testCreateTask =
(Attachment invalidAttachment) -> {
invalidAttachment -> {
Task taskWithInvalidAttachment = makeNewTask(taskService);
taskWithInvalidAttachment.addAttachment(invalidAttachment);
ThrowingCallable call =
() -> {
taskService.createTask(taskWithInvalidAttachment);
};
ThrowingCallable call = () -> taskService.createTask(taskWithInvalidAttachment);
assertThatThrownBy(call)
.describedAs(
"Should have thrown an InvalidArgumentException, "
@ -560,10 +543,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
ThrowingCallable call = () -> taskService.createTask(newTask);
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
}
@ -576,10 +556,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
ThrowingCallable call = () -> taskService.createTask(newTask);
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -594,10 +571,7 @@ class CreateTaskAccTest extends AbstractAccTest {
if (objectReference != null) {
newTask.setPrimaryObjRef(objectReference);
}
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
ThrowingCallable call = () -> taskService.createTask(newTask);
assertThatThrownBy(call)
.describedAs(
"Should have thrown an InvalidArgumentException, because ObjRef-ObjRef is null.")
@ -679,12 +653,10 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
HashMap<String, String> callbackInfo = new HashMap<>();
for (int i = 1; i <= 10; i++) {
callbackInfo.put("info_" + i, "Value of info_" + i);
}
Map<String, String> callbackInfo = createSimpleCustomProperties(10);
newTask.setCallbackInfo(callbackInfo);
Task createdTask = taskService.createTask(newTask);
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
@ -694,7 +666,7 @@ class CreateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);
@ -713,10 +685,7 @@ class CreateTaskAccTest extends AbstractAccTest {
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_B", "SYSTEM_B", "INSTANCE_B", "VNR", "1234567"));
ThrowingCallable call =
() -> {
taskService.createTask(newTask);
};
ThrowingCallable call = () -> taskService.createTask(newTask);
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -726,10 +695,7 @@ class CreateTaskAccTest extends AbstractAccTest {
Task existingTask = taskService.getTask("TKI:000000000000000000000000000000000000");
ThrowingCallable call =
() -> {
taskService.createTask(existingTask);
};
ThrowingCallable call = () -> taskService.createTask(existingTask);
assertThatThrownBy(call).isInstanceOf(TaskAlreadyExistException.class);
}
@ -739,10 +705,7 @@ class CreateTaskAccTest extends AbstractAccTest {
Task task = taskService.newTask("TEAMLEAD_2", "DOMAIN_A");
ThrowingCallable call =
() -> {
taskService.createTask(task);
};
ThrowingCallable call = () -> taskService.createTask(task);
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
}
@ -755,7 +718,7 @@ class CreateTaskAccTest extends AbstractAccTest {
String wbId = "WBI:100000000000000000000000000000000008";
Task taskToPreventWorkbasketDeletion = taskService.newTask(wbId);
taskToPreventWorkbasketDeletion = setTaskProperties(taskToPreventWorkbasketDeletion);
setTaskProperties(taskToPreventWorkbasketDeletion);
taskService.createTask(taskToPreventWorkbasketDeletion);
taskService.cancelTask(taskToPreventWorkbasketDeletion.getId());
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();

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

@ -42,12 +42,11 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
@SuppressWarnings({"checkstyle:LineLength"})
public class ServiceLevelPriorityAccTest extends AbstractAccTest {
private TaskService taskService;
private ClassificationService classificationService;
private WorkingDaysToDaysConverter converter;
private final TaskService taskService;
private final ClassificationService classificationService;
private final WorkingDaysToDaysConverter converter;
ServiceLevelPriorityAccTest() {
super();
WorkingDaysToDaysConverter.setGermanPublicHolidaysEnabled(true);
taskService = taskanaEngine.getTaskService();
classificationService = taskanaEngine.getClassificationService();
@ -173,9 +172,7 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
void should_VerifyThatCreateAndPlannedAreClose()
throws NotAuthorizedException, InvalidArgumentException, ClassificationNotFoundException,
WorkbasketNotFoundException, TaskAlreadyExistException {
void should_VerifyThatCreateAndPlannedAreClose() throws Exception {
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
Instant planned = moveForwardToWorkingDay(Instant.now().plus(2, ChronoUnit.HOURS));
@ -190,17 +187,17 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
assertThat(createdTask.getPlanned()).isEqualTo(planned);
assertThat(createdTask.getCreated()).isBefore(createdTask.getPlanned());
// verify that planned takes place 2 hours after creation (+- 5 seconds)
Instant plannedAdjusted = createdTask.getPlanned().minus(2, ChronoUnit.HOURS);
assertThat(plannedAdjusted)
.isCloseTo(createdTask.getCreated(), new TemporalUnitWithinOffset(5L, ChronoUnit.SECONDS));
assertThat(createdTask.getPlanned())
.isCloseTo(
moveForwardToWorkingDay(createdTask.getCreated()),
new TemporalUnitWithinOffset(2L, ChronoUnit.HOURS));
}
/* UPDATE TASK */
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
public void should_ThrowException_When_DueAndPlannedAreChangedInconsistently() throws Exception {
void should_ThrowException_When_DueAndPlannedAreChangedInconsistently() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000"); // P1D
task.setDue(Instant.parse("2020-07-02T00:00:00Z"));
@ -655,12 +652,4 @@ public class ServiceLevelPriorityAccTest extends AbstractAccTest {
assertThat(task.getDue()).isEqualTo(getInstant("2020-04-14T07:00:00")); // Tuesday
assertThat(task.getPlanned()).isEqualTo(getInstant("2020-04-09T07:00:00")); // Thursday
}
protected Instant moveForwardToWorkingDay(Instant date) {
return converter.addWorkingDaysToInstant(date, Duration.ofDays(0));
}
protected Instant moveBackToWorkingDay(Instant date) {
return converter.subtractWorkingDaysFromInstant(date, Duration.ofDays(0));
}
}

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

@ -5,7 +5,6 @@ import static org.assertj.core.api.Assertions.assertThatCode;
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.HashMap;
@ -38,9 +37,7 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
@ExtendWith(JaasExtension.class)
class UpdateTaskAccTest extends AbstractAccTest {
UpdateTaskAccTest() {
super();
}
private final TaskService taskService = taskanaEngine.getTaskService();
@WithAccessId(user = "user_1_1", groups = "group_1")
@Test
@ -49,7 +46,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Instant modifiedOriginal = task.getModified();
task.setPrimaryObjRef(
@ -78,7 +74,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
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"));
@ -106,7 +101,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
void should_ThrowException_When_MandatoryPrimaryObjectReferenceIsNotSetOrIncomplete()
throws NotAuthorizedException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setPrimaryObjRef(null);
assertThatThrownBy(() -> taskService.updateTask(task))
@ -137,7 +131,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
TaskNotFoundException, ConcurrencyException, AttachmentPersistenceException,
InvalidStateException, InterruptedException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final Task task2 = taskService.getTask("TKI:000000000000000000000000000000000000");
@ -148,7 +141,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
// TODO flaky test ... if speed is too high,
assertThatThrownBy(() -> taskService.updateTask(task2))
.isInstanceOf(ConcurrencyException.class)
.withFailMessage("The task has already been updated by another user");
.hasMessage("The task has already been updated by another user");
}
@WithAccessId(user = "admin")
@ -157,25 +150,16 @@ class UpdateTaskAccTest extends AbstractAccTest {
void should_UpdateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws NotAuthorizedException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
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 {
void should_UpdateTaskProperties_When_ClassificationOfTaskIsChanged() throws Exception {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
final ClassificationSummary classificationSummary = task.getClassificationSummary();
task.setClassificationKey("T2100");
@ -196,8 +180,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
void should_UpdateReadFlagOfTask_When_SetTaskReadIsCalled()
throws TaskNotFoundException, NotAuthorizedException {
TaskService taskService = taskanaEngine.getTaskService();
taskService.setTaskRead("TKI:000000000000000000000000000000000030", true);
Task updatedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
assertThat(updatedTask).isNotNull();
@ -220,7 +202,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
task.setCustomAttribute("1", "T2100");
Task updatedTask = taskService.updateTask(task);
@ -234,7 +215,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
void should_ThrowException_When_ModificationOfWorkbasketKeyIsAttempted()
throws NotAuthorizedException, TaskNotFoundException {
TaskService taskService = taskanaEngine.getTaskService();
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
((TaskImpl) task).setWorkbasketKey("USER_2_2");
@ -257,7 +237,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
customProperties.put("14", null);
customProperties.put("3", "This is modifiedValue 3");
customProperties.put("16", "This is modifiedValue 16");
TaskService taskService = taskanaEngine.getTaskService();
List<String> taskIds = taskService.updateTasks(por, customProperties);
assertThat(taskIds).isEmpty();
@ -278,7 +257,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
customProperties.put("14", null);
customProperties.put("3", "This is modifiedValue 3");
customProperties.put("16", "This is modifiedValue 16");
TaskService taskService = taskanaEngine.getTaskService();
List<String> taskIds = taskService.updateTasks(por, customProperties);
assertThat(taskIds).hasSize(6);
@ -305,7 +283,6 @@ class UpdateTaskAccTest extends AbstractAccTest {
customProperties.put("5", "This is modifiedValue 5");
customProperties.put("10", "This is modifiedValue 10");
customProperties.put("12", "This is modifiedValue 12");
TaskService taskService = taskanaEngine.getTaskService();
List<String> changedTasks = taskService.updateTasks(taskIds, customProperties);
assertThat(changedTasks).hasSize(3);
@ -326,12 +303,13 @@ class UpdateTaskAccTest extends AbstractAccTest {
TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
ConcurrencyException, AttachmentPersistenceException, InvalidStateException {
TaskService taskService = taskanaEngine.getTaskService();
Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
newTask.setClassificationKey("T2100");
newTask.setPrimaryObjRef(
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
Task createdTask = taskService.createTask(newTask);
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
assertThat(createdTask).isNotNull();
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
@ -341,7 +319,7 @@ class UpdateTaskAccTest extends AbstractAccTest {
assertThat(createdTask.getClaimed()).isNull();
assertThat(createdTask.getCompleted()).isNull();
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(createdTask.getCreated());
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
assertThat(createdTask.getParentBusinessProcessId()).isNull();
assertThat(createdTask.getPriority()).isEqualTo(2);