Closes #2205 - Refactor CreateTaskAccTest to use test-api
This commit is contained in:
jamesrdi
Elena Mokeeva
parent
34752acd79
commit
ee914db0ca
|
|
@ -0,0 +1,863 @@
|
|||
package acceptance.task.create;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
import static org.assertj.core.api.Assertions.catchThrowableOfType;
|
||||
import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification;
|
||||
import static pro.taskana.testapi.DefaultTestEntities.defaultTestObjectReference;
|
||||
import static pro.taskana.testapi.DefaultTestEntities.defaultTestWorkbasket;
|
||||
|
||||
import java.time.Duration;
|
||||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
import java.util.stream.Stream;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.DynamicTest;
|
||||
import org.junit.jupiter.api.Nested;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestFactory;
|
||||
import org.junit.jupiter.api.TestInstance;
|
||||
import org.junit.jupiter.api.TestInstance.Lifecycle;
|
||||
import org.junit.jupiter.api.TestTemplate;
|
||||
import org.junit.jupiter.api.function.ThrowingConsumer;
|
||||
import pro.taskana.TaskanaConfiguration;
|
||||
import pro.taskana.classification.api.ClassificationService;
|
||||
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
|
||||
import pro.taskana.classification.api.models.ClassificationSummary;
|
||||
import pro.taskana.classification.internal.models.ClassificationSummaryImpl;
|
||||
import pro.taskana.common.api.TaskanaEngine;
|
||||
import pro.taskana.common.api.WorkingTimeCalculator;
|
||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.common.internal.util.Pair;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskService;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
|
||||
import pro.taskana.task.api.models.Attachment;
|
||||
import pro.taskana.task.api.models.AttachmentSummary;
|
||||
import pro.taskana.task.api.models.ObjectReference;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.internal.models.TaskImpl;
|
||||
import pro.taskana.testapi.TaskanaConfigurationModifier;
|
||||
import pro.taskana.testapi.TaskanaInject;
|
||||
import pro.taskana.testapi.TaskanaIntegrationTest;
|
||||
import pro.taskana.testapi.builder.ClassificationBuilder;
|
||||
import pro.taskana.testapi.builder.ObjectReferenceBuilder;
|
||||
import pro.taskana.testapi.builder.TaskAttachmentBuilder;
|
||||
import pro.taskana.testapi.builder.UserBuilder;
|
||||
import pro.taskana.testapi.builder.WorkbasketAccessItemBuilder;
|
||||
import pro.taskana.testapi.security.WithAccessId;
|
||||
import pro.taskana.user.api.UserService;
|
||||
import pro.taskana.user.api.models.User;
|
||||
import pro.taskana.workbasket.api.WorkbasketPermission;
|
||||
import pro.taskana.workbasket.api.WorkbasketService;
|
||||
import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
|
||||
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
|
||||
import pro.taskana.workbasket.api.models.WorkbasketSummary;
|
||||
|
||||
@TaskanaIntegrationTest
|
||||
class CreateTaskAccTest {
|
||||
@TaskanaInject TaskanaEngine taskanaEngine;
|
||||
@TaskanaInject TaskService taskService;
|
||||
@TaskanaInject ClassificationService classificationService;
|
||||
@TaskanaInject WorkbasketService workbasketService;
|
||||
@TaskanaInject UserService userService;
|
||||
|
||||
ClassificationSummary defaultClassificationSummary;
|
||||
WorkbasketSummary defaultWorkbasketSummary;
|
||||
ObjectReference defaultObjectReference;
|
||||
Attachment defaultAttachment;
|
||||
User defaultUser;
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@BeforeAll
|
||||
void setup() throws Exception {
|
||||
defaultClassificationSummary =
|
||||
defaultTestClassification().buildAndStoreAsSummary(classificationService);
|
||||
defaultWorkbasketSummary = defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
|
||||
|
||||
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
|
||||
.workbasketId(defaultWorkbasketSummary.getId())
|
||||
.accessId("user-1-2")
|
||||
.permission(WorkbasketPermission.OPEN)
|
||||
.permission(WorkbasketPermission.READ)
|
||||
.permission(WorkbasketPermission.APPEND)
|
||||
.buildAndStore(workbasketService);
|
||||
defaultObjectReference = defaultTestObjectReference().build();
|
||||
defaultAttachment =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.build();
|
||||
defaultUser =
|
||||
UserBuilder.newUser()
|
||||
.id("user-1-2")
|
||||
.longName("Mustermann, Max - (user-1-2)")
|
||||
.firstName("Max")
|
||||
.lastName("Mustermann")
|
||||
.buildAndStore(userService);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_NotSetAttachmentSummariesToNull_When_CreatingNewTaskWithTaskService()
|
||||
throws Exception {
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
|
||||
|
||||
assertThat(task.getAttachments()).isNotNull();
|
||||
assertThat(task.asSummary().getAttachmentSummaries()).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_CreateTask_When_UserIsMemberOfTaskRouterRole() throws Exception {
|
||||
Task newTask = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1", groups = "cn=routers,cn=groups,OU=Test,O=TASKANA")
|
||||
@Test
|
||||
void should_CreateTask_When_UserIsMemberOfGroupWithTaskRouterRole() throws Exception {
|
||||
Task newTask = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test // Fail
|
||||
void should_BeAbleToCreateNewTask_When_UsingTaskCopy() throws Exception {
|
||||
Attachment attachment =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
Task task = createDefaultTask();
|
||||
task.addAttachment(attachment);
|
||||
taskService.createTask(task);
|
||||
Task oldTask = taskService.getTask(task.getId());
|
||||
|
||||
Task newTask = oldTask.copy();
|
||||
newTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(newTask.getId()).isNotNull();
|
||||
assertThat(newTask.getId()).isNotEqualTo(oldTask.getId());
|
||||
assertThat(newTask.getAttachments())
|
||||
.extracting(AttachmentSummary::getTaskId)
|
||||
.contains(newTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateSimpleManualTask() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getOwner()).isEqualTo("user-1-2");
|
||||
assertThat(createdTask.getWorkbasketKey()).isEqualTo(defaultWorkbasketSummary.getKey());
|
||||
assertThat(createdTask.getName()).isEqualTo(defaultClassificationSummary.getName());
|
||||
assertThat(createdTask.getPrimaryObjRef()).isEqualTo(defaultObjectReference);
|
||||
assertThat(createdTask.getCreated()).isNotNull();
|
||||
assertThat(createdTask.getModified()).isNotNull();
|
||||
assertThat(createdTask.getBusinessProcessId()).isNotNull();
|
||||
assertThat(createdTask.getClaimed()).isNull();
|
||||
assertThat(createdTask.getCompleted()).isNull();
|
||||
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
|
||||
assertThat(createdTask.getReceived()).isNull();
|
||||
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(createdTask.getParentBusinessProcessId()).isNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(defaultClassificationSummary.getPriority());
|
||||
assertThat(createdTask.isRead()).isFalse();
|
||||
assertThat(createdTask.isTransferred()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_PreventTimestampServiceLevelMismatch_When_ConfigurationPreventsIt() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
Instant planned = Instant.parse("2018-01-02T00:00:00Z");
|
||||
task.setPlanned(planned);
|
||||
Instant due = Instant.parse("2018-02-15T00:00:00Z");
|
||||
task.setDue(due);
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("not matching the service level");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateTask_When_ObjectReferenceSystemAndSystemInstanceIsNull() throws Exception {
|
||||
ObjectReference objectReference =
|
||||
ObjectReferenceBuilder.newObjectReference()
|
||||
.system(null)
|
||||
.systemInstance(null)
|
||||
.company(defaultObjectReference.getCompany())
|
||||
.type(defaultObjectReference.getType())
|
||||
.value(defaultObjectReference.getValue())
|
||||
.build();
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
|
||||
task.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
task.setPrimaryObjRef(objectReference);
|
||||
task.setOwner("user-1-2");
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@TestTemplate
|
||||
void should_CreateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
|
||||
throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTheSameTaskTwice() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
task.setExternalId("MyExternalId");
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
|
||||
Task task2 = createDefaultTask();
|
||||
task2.setExternalId("MyExternalId");
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task2);
|
||||
TaskAlreadyExistException e = catchThrowableOfType(call, TaskAlreadyExistException.class);
|
||||
assertThat(e.getExternalId()).isEqualTo("MyExternalId");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateTask_When_CustomAttributesAreSpecified() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
Map<String, String> customAttributesForCreate = createSimpleCustomPropertyMap(13);
|
||||
task.setCustomAttributeMap(customAttributesForCreate);
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
// verify that the map is correctly retrieved from the database
|
||||
Task retrievedTask = taskService.getTask(createdTask.getId());
|
||||
Map<String, String> customAttributesFromDb = retrievedTask.getCustomAttributeMap();
|
||||
assertThat(customAttributesFromDb).isNotNull();
|
||||
assertThat(customAttributesFromDb).isEqualTo(customAttributesForCreate);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateTask_When_AttachmentIsSpecified() throws Exception {
|
||||
Map<String, String> customAttributesForCreate = createSimpleCustomPropertyMap(27);
|
||||
ClassificationSummary classificationSummary =
|
||||
defaultTestClassification()
|
||||
.type("DOCUMENT")
|
||||
.category("EXTERNAL")
|
||||
.buildAndStoreAsSummary(classificationService, "admin");
|
||||
Task task = createDefaultTask();
|
||||
Attachment attachment =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(classificationSummary)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.customAttributes(customAttributesForCreate)
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
task.addAttachment(attachment);
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getAttachments()).hasSize(1);
|
||||
Attachment firstAttachment = createdTask.getAttachments().get(0);
|
||||
assertThat(firstAttachment.getCustomAttributeMap().toString())
|
||||
.contains(
|
||||
IntStream.rangeClosed(1, 27)
|
||||
.mapToObj(String::valueOf)
|
||||
.map(
|
||||
number ->
|
||||
String.format("Property_%s=Property Value of Property_%s", number, number))
|
||||
.collect(Collectors.toSet()));
|
||||
assertThat(firstAttachment.getCreated()).isNotNull();
|
||||
assertThat(firstAttachment.getModified()).isNotNull();
|
||||
assertThat(firstAttachment.getModified()).isEqualTo(firstAttachment.getCreated());
|
||||
assertThat(firstAttachment.getClassificationSummary()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getId()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getKey()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getType()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getCategory()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getDomain()).isNotNull();
|
||||
assertThat(firstAttachment.getClassificationSummary().getServiceLevel()).isNotNull();
|
||||
assertThat(firstAttachment.getReceived()).isNotNull();
|
||||
assertThat(firstAttachment.getChannel()).isNotNull();
|
||||
assertThat(firstAttachment.getObjectReference()).isNotNull();
|
||||
// verify that the map is correctly retrieved from the database
|
||||
Map<String, String> customAttributesFromDb = firstAttachment.getCustomAttributeMap();
|
||||
assertThat(customAttributesFromDb).isNotNull();
|
||||
assertThat(customAttributesForCreate).isEqualTo(customAttributesFromDb);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateTask_When_MultipleAttachmentsAreSpecified() throws Exception {
|
||||
Instant earlierInstant = Instant.parse("2018-01-12T00:00:00Z");
|
||||
Instant laterInstant = Instant.parse("2018-01-15T00:00:00Z");
|
||||
Task task = createDefaultTask();
|
||||
Attachment attachment =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.received(laterInstant)
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
Attachment attachment2 =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.received(earlierInstant)
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
task.addAttachment(attachment);
|
||||
task.addAttachment(attachment2);
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
assertThat(createdTask.getId()).isNotNull();
|
||||
assertThat(createdTask.getCreator()).isEqualTo("user-1-2");
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(readTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(readTask.getAttachments()).isNotNull();
|
||||
assertThat(readTask.getAttachments()).hasSize(2);
|
||||
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified())
|
||||
.isEqualTo(readTask.getAttachments().get(0).getCreated());
|
||||
// assertThat(readTask.getAttachments().get(0).getClassification()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
|
||||
assertThat(readTask.getReceived()).isEqualTo(earlierInstant);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetPriorityAndDurationCorrectly_When_UsingClassificationOfAttachment()
|
||||
throws Exception {
|
||||
ClassificationSummary classificationSummary =
|
||||
defaultTestClassification()
|
||||
.priority(0)
|
||||
.serviceLevel("P3D")
|
||||
.buildAndStoreAsSummary(classificationService, "admin");
|
||||
ClassificationSummary classificationSummary1 =
|
||||
defaultTestClassification()
|
||||
.priority(50)
|
||||
.serviceLevel("P0D")
|
||||
.buildAndStoreAsSummary(classificationService, "admin");
|
||||
ClassificationSummary classificationSummary2 =
|
||||
defaultTestClassification()
|
||||
.priority(99)
|
||||
.serviceLevel("P5D")
|
||||
.buildAndStoreAsSummary(classificationService, "admin");
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
|
||||
task.setClassificationKey(classificationSummary.getKey());
|
||||
task.setPrimaryObjRef(defaultObjectReference);
|
||||
task.setOwner("user-1-2");
|
||||
task.setPlanned(Instant.now());
|
||||
Attachment attachment1 =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(classificationSummary1)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
Attachment attachment2 =
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.objectReference(defaultObjectReference)
|
||||
.classificationSummary(classificationSummary2)
|
||||
.created(Instant.now())
|
||||
.modified(Instant.now())
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.channel("E-MAIL")
|
||||
.build();
|
||||
task.addAttachment(attachment1);
|
||||
task.addAttachment(attachment2);
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask.getId()).isNotNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(99);
|
||||
assertThat(createdTask.getDue()).isNotNull().isEqualTo(createdTask.getPlanned());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@TestFactory
|
||||
Stream<DynamicTest> should_ThrowException_When_AttachmentIsInvalid() throws Exception {
|
||||
List<Pair<String, ObjectReference>> list =
|
||||
List.of(
|
||||
Pair.of("With Object Reference set to Null", null),
|
||||
Pair.of(
|
||||
"With Value of Object Reference set to Null",
|
||||
createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", "ArchiveId", null)),
|
||||
Pair.of(
|
||||
"With Type of Object Reference set to Null",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
null,
|
||||
"12345678901234567890123456789012345678901234567890")),
|
||||
Pair.of(
|
||||
"With Company of Object Reference set to Null",
|
||||
createObjectReference(
|
||||
null,
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890")));
|
||||
ThrowingConsumer<Pair<String, ObjectReference>> testCreateTask =
|
||||
t -> {
|
||||
Task taskWithInvalidAttachment = createDefaultTask();
|
||||
defaultAttachment.setObjectReference(t.getRight());
|
||||
taskWithInvalidAttachment.addAttachment(defaultAttachment);
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(taskWithInvalidAttachment);
|
||||
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
};
|
||||
return DynamicTest.stream(list.iterator(), Pair::getLeft, testCreateTask);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_UseCustomName_For_NewTask() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
task.setName("Test Name");
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getName()).isEqualTo("Test Name");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_UseClassificationMetadataFromCorrectDomain_For_NewTask() throws Exception {
|
||||
ClassificationSummary classificationSummary =
|
||||
ClassificationBuilder.newClassification()
|
||||
.key(defaultClassificationSummary.getKey())
|
||||
.priority(99)
|
||||
.domain("DOMAIN_B")
|
||||
.buildAndStoreAsSummary(classificationService, "admin");
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getKey(), "DOMAIN_A");
|
||||
task.setClassificationKey(classificationSummary.getKey());
|
||||
task.setPrimaryObjRef(defaultObjectReference);
|
||||
task.setOwner("user-1-2");
|
||||
task.setName("Test Name");
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(0);
|
||||
assertThat(createdTask.getClassificationSummary()).isEqualTo(defaultClassificationSummary);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_WorkbasketDoesNotExist() {
|
||||
Task task = taskService.newTask("UNKNOWN");
|
||||
task.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
task.setPrimaryObjRef(defaultObjectReference);
|
||||
task.setOwner("user-1-2");
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class);
|
||||
assertThat(e.getId()).isEqualTo("UNKNOWN");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_TestGetException_When_AppendIsNotPermitted() throws Exception {
|
||||
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
|
||||
.workbasketId(defaultWorkbasketSummary.getId())
|
||||
.accessId("user-1-1")
|
||||
.permission(WorkbasketPermission.OPEN)
|
||||
.permission(WorkbasketPermission.READ)
|
||||
.buildAndStore(workbasketService, "admin");
|
||||
Task task = createDefaultTask();
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
|
||||
NotAuthorizedOnWorkbasketException e =
|
||||
catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-1-1");
|
||||
assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e.getRequiredPermissions()).contains(WorkbasketPermission.APPEND);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@TestFactory
|
||||
Stream<DynamicTest>
|
||||
should_ThrowException_When_MandatoryPrimaryObjectReferenceIsNotSetOrIncomplete() {
|
||||
List<Pair<String, ObjectReference>> list =
|
||||
List.of(
|
||||
Pair.of("Object Reference is Null", null),
|
||||
Pair.of(
|
||||
"Value of Object Reference is Null",
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null)),
|
||||
Pair.of(
|
||||
"Type of Object Reference is Null",
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567")),
|
||||
Pair.of(
|
||||
"Company of Object Reference is Null",
|
||||
createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567")));
|
||||
ThrowingConsumer<Pair<String, ObjectReference>> testCreateTask =
|
||||
t -> {
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
|
||||
task.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
task.setOwner("user-1-2");
|
||||
if (t.getRight() != null) {
|
||||
task.setPrimaryObjRef(t.getRight());
|
||||
}
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
};
|
||||
|
||||
return DynamicTest.stream(list.iterator(), Pair::getLeft, testCreateTask);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetDomainFromWorkbasket() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getDomain()).isNotNull();
|
||||
assertThat(createdTask.getDomain()).isEqualTo(defaultWorkbasketSummary.getDomain());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ReadSameTaskObjectAsCreated() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
for (TaskCustomField taskCustomField : TaskCustomField.values()) {
|
||||
task.setCustomField(taskCustomField, taskCustomField.name());
|
||||
}
|
||||
task.setCustomAttributeMap(createSimpleCustomPropertyMap(5));
|
||||
task.setDescription("Description of test task");
|
||||
task.setNote("My note");
|
||||
task.addAttachment(defaultAttachment);
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
|
||||
assertThat(readTask).isEqualTo(createdTask);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_CreateSimpleTask_When_CallbackInfoIsSet() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
Map<String, String> callbackInfo = createSimpleCustomPropertyMap(10);
|
||||
task.setCallbackInfo(callbackInfo);
|
||||
Task createdTask = taskService.createTask(task);
|
||||
moveForwardToWorkingDay(createdTask.getCreated());
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
|
||||
Task retrievedTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(retrievedTask.getCallbackInfo()).isEqualTo(callbackInfo);
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ThrowException_When_NoUserIdIsSetAndSecurityIsOn() {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
NotAuthorizedOnWorkbasketException e =
|
||||
catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e.getCurrentUserId()).isEqualTo(null);
|
||||
assertThat(e.getRequiredPermissions()).containsExactly(WorkbasketPermission.READ);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithNonEmptyId() {
|
||||
Task task = createDefaultTask();
|
||||
((TaskImpl) task).setId("TKI:000000000000000000000000000000000000");
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_UserNotAuthorizedOnWorkbasket() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
NotAuthorizedOnWorkbasketException e =
|
||||
catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
|
||||
assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
|
||||
assertThat(e.getCurrentUserId()).isEqualTo("user-1-1");
|
||||
assertThat(e.getRequiredPermissions()).containsExactly(WorkbasketPermission.READ);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_NotThrowNullPointerException_When_CreatingTaskWithoutWorkbasketSummary() {
|
||||
Task task = new TaskImpl();
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test // Fail
|
||||
void should_ThrowException_When_WorkbasketMarkedForDeletion() throws Exception {
|
||||
WorkbasketSummary newWorkbasketSummary =
|
||||
defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
|
||||
Task taskToPreventWorkbasketDeletion = taskService.newTask(newWorkbasketSummary.getId());
|
||||
taskToPreventWorkbasketDeletion.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
taskToPreventWorkbasketDeletion.setPrimaryObjRef(defaultObjectReference);
|
||||
taskToPreventWorkbasketDeletion.setOwner("user-1-2");
|
||||
taskService.createTask(taskToPreventWorkbasketDeletion);
|
||||
taskService.cancelTask(taskToPreventWorkbasketDeletion.getId());
|
||||
Task testTask = taskService.newTask(newWorkbasketSummary.getId());
|
||||
testTask.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
testTask.setPrimaryObjRef(defaultObjectReference);
|
||||
|
||||
workbasketService.deleteWorkbasket(newWorkbasketSummary.getId());
|
||||
ThrowingCallable call = () -> taskService.createTask(testTask);
|
||||
|
||||
WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class);
|
||||
assertThat(e.getId()).isEqualTo(newWorkbasketSummary.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithAttachmentClassificationNull() {
|
||||
Task task = createDefaultTask();
|
||||
task.addAttachment(
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.classificationSummary(null)
|
||||
.objectReference(defaultObjectReference)
|
||||
.channel("E-MAIL")
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.build());
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("Classification of Attachment must not be null.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithAttachmentObjectReferenceNull() {
|
||||
Task task = createDefaultTask();
|
||||
task.addAttachment(
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.classificationSummary(defaultClassificationSummary)
|
||||
.objectReference(null)
|
||||
.channel("E-MAIL")
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.build());
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("ObjectReference of Attachment must not be null.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithNotExistingAttachmentClassification() {
|
||||
ClassificationSummary classificationSummary =
|
||||
classificationService
|
||||
.newClassification("NOT_EXISTING", defaultClassificationSummary.getDomain(), "")
|
||||
.asSummary();
|
||||
Task task = createDefaultTask();
|
||||
|
||||
task.addAttachment(
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.classificationSummary(classificationSummary)
|
||||
.objectReference(defaultObjectReference)
|
||||
.channel("E-MAIL")
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.build());
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
ClassificationNotFoundException e =
|
||||
catchThrowableOfType(call, ClassificationNotFoundException.class);
|
||||
assertThat(e.getClassificationKey()).isEqualTo("NOT_EXISTING");
|
||||
assertThat(e.getDomain()).isEqualTo(defaultClassificationSummary.getDomain());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithMissingAttachmentClassificationKey() {
|
||||
Task task = createDefaultTask();
|
||||
ClassificationSummary classificationSummary = new ClassificationSummaryImpl();
|
||||
task.addAttachment(
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.classificationSummary(classificationSummary)
|
||||
.objectReference(defaultObjectReference)
|
||||
.channel("E-MAIL")
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.build());
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("ClassificationKey of Attachment must not be empty.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_FetchAttachmentClassification_When_CreatingTaskWithAttachments() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
ClassificationSummary newClassificationSummary =
|
||||
classificationService
|
||||
.newClassification(
|
||||
defaultClassificationSummary.getKey(), defaultClassificationSummary.getDomain(), "")
|
||||
.asSummary();
|
||||
task.addAttachment(
|
||||
TaskAttachmentBuilder.newAttachment()
|
||||
.classificationSummary(newClassificationSummary)
|
||||
.objectReference(defaultObjectReference)
|
||||
.channel("E-MAIL")
|
||||
.received(Instant.parse("2018-01-15T00:00:00Z"))
|
||||
.customAttributes(createSimpleCustomPropertyMap(3))
|
||||
.build());
|
||||
|
||||
assertThat(newClassificationSummary.getServiceLevel()).isNull();
|
||||
|
||||
task = taskService.createTask(task);
|
||||
newClassificationSummary = task.getAttachments().get(0).getClassificationSummary();
|
||||
|
||||
assertThat(newClassificationSummary.getId()).isNotNull();
|
||||
assertThat(newClassificationSummary.getDomain()).isNotNull();
|
||||
assertThat(newClassificationSummary.getServiceLevel()).isNotNull();
|
||||
}
|
||||
|
||||
private Map<String, String> createSimpleCustomPropertyMap(int propertiesCount) {
|
||||
return IntStream.rangeClosed(1, propertiesCount)
|
||||
.mapToObj(String::valueOf)
|
||||
.collect(Collectors.toMap("Property_"::concat, "Property Value of Property_"::concat));
|
||||
}
|
||||
|
||||
private Task createDefaultTask() {
|
||||
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
|
||||
task.setClassificationKey(defaultClassificationSummary.getKey());
|
||||
task.setPrimaryObjRef(defaultObjectReference);
|
||||
task.setOwner("user-1-2");
|
||||
return task;
|
||||
}
|
||||
|
||||
private Instant moveForwardToWorkingDay(Instant date) {
|
||||
WorkingTimeCalculator workingTimeCalculator = taskanaEngine.getWorkingTimeCalculator();
|
||||
return workingTimeCalculator.addWorkingTime(date, Duration.ZERO);
|
||||
}
|
||||
|
||||
private ObjectReference createObjectReference(
|
||||
String company, String system, String instance, String type, String value) {
|
||||
return ObjectReferenceBuilder.newObjectReference()
|
||||
.company(company)
|
||||
.system(system)
|
||||
.systemInstance(instance)
|
||||
.type(type)
|
||||
.value(value)
|
||||
.build();
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WithAdditionalUserInfoEnabled implements TaskanaConfigurationModifier {
|
||||
|
||||
@TaskanaInject TaskService taskService;
|
||||
|
||||
@Override
|
||||
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
|
||||
return builder.addAdditionalUserInfo(true);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetOwnerLongName() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getOwnerLongName()).isEqualTo("Mustermann, Max - (user-1-2)");
|
||||
}
|
||||
}
|
||||
|
||||
@Nested
|
||||
@TestInstance(Lifecycle.PER_CLASS)
|
||||
class WithEnforceServiceLevelDisabled implements TaskanaConfigurationModifier {
|
||||
|
||||
@TaskanaInject TaskService taskService;
|
||||
|
||||
@Override
|
||||
public TaskanaConfiguration.Builder modify(TaskanaConfiguration.Builder builder) {
|
||||
return builder.enforceServiceLevel(false);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-2")
|
||||
@Test
|
||||
void should_SetDueAndPlanned_When_DueAndPlannedMismatchServiceLevel() throws Exception {
|
||||
Task task = createDefaultTask();
|
||||
Instant planned = Instant.parse("2018-01-02T00:00:00Z");
|
||||
task.setPlanned(planned);
|
||||
Instant due = Instant.parse("2018-02-15T00:00:00Z");
|
||||
task.setDue(due);
|
||||
|
||||
Task createdTask = taskService.createTask(task);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(planned);
|
||||
assertThat(createdTask.getDue()).isEqualTo(due);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3,6 +3,7 @@ taskana.roles.admin=admin | uid=admin,cn=users,OU=Test,O=TASKANA
|
|||
taskana.roles.business_admin=businessadmin | cn=business-admins,cn=groups,OU=Test,O=TASKANA
|
||||
taskana.roles.monitor=monitor | cn=monitor-users,cn=groups,OU=Test,O=TASKANA
|
||||
taskana.roles.task_admin=taskadmin
|
||||
taskana.roles.task_router=cn=routers,cn=groups,OU=Test,O=TASKANA | user-taskrouter
|
||||
taskana.domains=DOMAIN_A | DOMAIN_B
|
||||
taskana.user.minimalPermissionsToAssignDomains=READ | OPEN
|
||||
taskana.classification.types=TASK | document
|
||||
|
|
|
|||
|
|
@ -1,946 +0,0 @@
|
|||
package acceptance.task.create;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import acceptance.TaskTestMapper;
|
||||
import acceptance.TaskanaEngineProxy;
|
||||
import java.time.Instant;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.IntStream;
|
||||
import org.apache.ibatis.session.Configuration;
|
||||
import org.apache.ibatis.session.SqlSession;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.TestTemplate;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import pro.taskana.TaskanaConfiguration;
|
||||
import pro.taskana.classification.api.ClassificationService;
|
||||
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
|
||||
import pro.taskana.classification.api.models.ClassificationSummary;
|
||||
import pro.taskana.classification.internal.models.ClassificationSummaryImpl;
|
||||
import pro.taskana.common.api.TaskanaEngine;
|
||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||
import pro.taskana.common.test.security.JaasExtension;
|
||||
import pro.taskana.common.test.security.WithAccessId;
|
||||
import pro.taskana.task.api.TaskCustomField;
|
||||
import pro.taskana.task.api.TaskService;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.exceptions.TaskAlreadyExistException;
|
||||
import pro.taskana.task.api.models.Attachment;
|
||||
import pro.taskana.task.api.models.AttachmentSummary;
|
||||
import pro.taskana.task.api.models.ObjectReference;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.internal.AttachmentMapper;
|
||||
import pro.taskana.task.internal.models.ObjectReferenceImpl;
|
||||
import pro.taskana.task.internal.models.TaskImpl;
|
||||
import pro.taskana.workbasket.api.WorkbasketService;
|
||||
import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
|
||||
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
|
||||
import pro.taskana.workbasket.api.models.Workbasket;
|
||||
|
||||
/** Acceptance test for all "create task" scenarios. */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class CreateTaskAccTest extends AbstractAccTest {
|
||||
|
||||
private final ClassificationService classificationService =
|
||||
taskanaEngine.getClassificationService();
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_NotSetAttachmentSummariesToNull_When_CreatingNewTaskWithTaskService() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.newTask("WBI:100000000000000000000000000000000006");
|
||||
assertThat(task.getAttachments()).isNotNull();
|
||||
assertThat(task.asSummary().getAttachmentSummaries()).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-taskrouter")
|
||||
@Test
|
||||
void should_CreateTask_When_UserIsMemberOfTaskRouterRole() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task newTask = taskService.newTask("WBI:100000000000000000000000000000000006");
|
||||
newTask.setClassificationKey("T2100");
|
||||
ObjectReferenceImpl objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
objectReference.setTaskId(newTask.getId());
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1", groups = "cn=routers,cn=groups,OU=Test,O=TASKANA")
|
||||
@Test
|
||||
void should_CreateTask_When_UserIsMemberOfGroupWithTaskRouterRole() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task newTask = taskService.newTask("WBI:100000000000000000000000000000000010");
|
||||
newTask.setClassificationKey("T2100");
|
||||
ObjectReferenceImpl objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
objectReference.setTaskId(newTask.getId());
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_BeAbleToCreateNewTask_When_TaskCopy() throws Exception {
|
||||
Task oldTask = taskService.getTask("TKI:000000000000000000000000000000000000");
|
||||
|
||||
Task newTask = oldTask.copy();
|
||||
newTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(newTask.getId()).isNotNull();
|
||||
assertThat(newTask.getId()).isNotEqualTo(oldTask.getId());
|
||||
assertThat(newTask.getAttachments())
|
||||
.extracting(AttachmentSummary::getTaskId)
|
||||
.contains(newTask.getId());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateSimpleManualTask() throws Exception {
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
ObjectReferenceImpl objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
objectReference.setTaskId(newTask.getId());
|
||||
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(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getOwner()).isEqualTo("user-1-1");
|
||||
assertThat(createdTask.getWorkbasketKey()).isEqualTo("USER-1-1");
|
||||
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
|
||||
assertThat(createdTask.getPrimaryObjRef()).isEqualTo(objectReference);
|
||||
assertThat(createdTask.getCreated()).isNotNull();
|
||||
assertThat(createdTask.getModified()).isNotNull();
|
||||
assertThat(createdTask.getBusinessProcessId()).isNotNull();
|
||||
assertThat(createdTask.getClaimed()).isNull();
|
||||
assertThat(createdTask.getCompleted()).isNull();
|
||||
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
|
||||
assertThat(createdTask.getReceived()).isNull();
|
||||
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(createdTask.getParentBusinessProcessId()).isNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(2);
|
||||
assertThat(createdTask.isRead()).isFalse();
|
||||
assertThat(createdTask.isTransferred()).isFalse();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateTaskWithAdditionalUserInfo() throws Exception {
|
||||
TaskanaConfiguration taskanaConfiguration =
|
||||
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
|
||||
.addAdditionalUserInfo(true)
|
||||
.build();
|
||||
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
ObjectReferenceImpl objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
objectReference.setTaskId(newTask.getId());
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
newTask.setOwner("user-1-1");
|
||||
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getOwner()).isEqualTo("user-1-1");
|
||||
assertThat(createdTask.getOwnerLongName()).isEqualTo("Mustermann, Max - (user-1-1)");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_PreventTimestampServiceLevelMismatch_When_ConfigurationPreventsIt() {
|
||||
// Given
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T6310");
|
||||
ObjectReference objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
newTask.setOwner("user-1-1");
|
||||
|
||||
// When
|
||||
Instant planned = Instant.parse("2018-01-02T00:00:00Z");
|
||||
newTask.setPlanned(planned);
|
||||
Instant due = Instant.parse("2018-02-15T00:00:00Z");
|
||||
newTask.setDue(due);
|
||||
|
||||
// Then
|
||||
assertThatThrownBy(() -> taskService.createTask(newTask))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("not matching the service level");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_AllowTimestampServiceLevelMismatch_When_ConfigurationAllowsIt() throws Exception {
|
||||
// Given
|
||||
TaskanaConfiguration taskanaConfiguration =
|
||||
new TaskanaConfiguration.Builder(AbstractAccTest.taskanaConfiguration)
|
||||
.enforceServiceLevel(false)
|
||||
.build();
|
||||
TaskanaEngine taskanaEngine = TaskanaEngine.buildTaskanaEngine(taskanaConfiguration);
|
||||
Task newTask = taskanaEngine.getTaskService().newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T6310");
|
||||
ObjectReference objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
newTask.setOwner("user-1-1");
|
||||
|
||||
// When
|
||||
Instant planned = Instant.parse("2018-01-02T00:00:00Z");
|
||||
newTask.setPlanned(planned);
|
||||
Instant due = Instant.parse("2018-02-15T00:00:00Z");
|
||||
newTask.setDue(due);
|
||||
Task createdTask = taskanaEngine.getTaskService().createTask(newTask);
|
||||
|
||||
// Then
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(planned);
|
||||
assertThat(createdTask.getDue()).isEqualTo(due);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateTask_When_ObjectReferenceSystemAndSystemInstanceIsNull() throws Exception {
|
||||
|
||||
String currentUser = taskanaEngine.getCurrentUserContext().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(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@TestTemplate
|
||||
void should_CreateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
|
||||
throws Exception {
|
||||
|
||||
String currentUser = taskanaEngine.getCurrentUserContext().getUserid();
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
ObjectReference objectReference =
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
newTask.setOwner(currentUser);
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTheSameTaskTwice() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setExternalId("MyExternalId");
|
||||
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.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
|
||||
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
|
||||
assertThat(createdTask.getExternalId()).isNotNull();
|
||||
assertThat(createdTask.getCreated()).isNotNull();
|
||||
assertThat(createdTask.getModified()).isNotNull();
|
||||
assertThat(createdTask.getBusinessProcessId()).isNotNull();
|
||||
assertThat(createdTask.getClaimed()).isNull();
|
||||
assertThat(createdTask.getCompleted()).isNull();
|
||||
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
|
||||
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(createdTask.getParentBusinessProcessId()).isNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(2);
|
||||
assertThat(createdTask.isRead()).isFalse();
|
||||
assertThat(createdTask.isTransferred()).isFalse();
|
||||
|
||||
Task newTask2 = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask2.setExternalId("MyExternalId");
|
||||
newTask2.setClassificationKey("T2100");
|
||||
newTask2.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask2);
|
||||
assertThatThrownBy(call).isInstanceOf(TaskAlreadyExistException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateTask_When_CustomAttributesAreSpecified() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
Map<String, String> customAttributesForCreate = createSimpleCustomPropertyMap(13);
|
||||
newTask.setCustomAttributeMap(customAttributesForCreate);
|
||||
Instant expectedReceived = Instant.parse("2019-09-13T08:44:17.588Z");
|
||||
newTask.setReceived(expectedReceived);
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getName()).isEqualTo("T-Vertragstermin VERA");
|
||||
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
|
||||
assertThat(createdTask.getCreated()).isNotNull();
|
||||
assertThat(createdTask.getModified()).isNotNull();
|
||||
assertThat(createdTask.getBusinessProcessId()).isNotNull();
|
||||
assertThat(createdTask.getClaimed()).isNull();
|
||||
assertThat(createdTask.getCompleted()).isNull();
|
||||
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
|
||||
assertThat(createdTask.getReceived()).isEqualTo(expectedReceived);
|
||||
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(createdTask.getParentBusinessProcessId()).isNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(2);
|
||||
assertThat(createdTask.isRead()).isFalse();
|
||||
assertThat(createdTask.isTransferred()).isFalse();
|
||||
// verify that the database content is as expected
|
||||
TaskanaEngineProxy engineProxy = new TaskanaEngineProxy(taskanaEngine);
|
||||
try {
|
||||
SqlSession session = engineProxy.getSqlSession();
|
||||
Configuration config = session.getConfiguration();
|
||||
if (!config.hasMapper(TaskTestMapper.class)) {
|
||||
config.addMapper(TaskTestMapper.class);
|
||||
}
|
||||
TaskTestMapper mapper = session.getMapper(TaskTestMapper.class);
|
||||
|
||||
engineProxy.openConnection();
|
||||
String customProperties = mapper.getCustomAttributesAsString(createdTask.getId());
|
||||
assertThat(customProperties)
|
||||
.contains(
|
||||
"\"Property_13\":\"Property Value of Property_13\"",
|
||||
"\"Property_12\":\"Property Value of Property_12\"",
|
||||
"\"Property_11\":\"Property Value of Property_11\"",
|
||||
"\"Property_10\":\"Property Value of Property_10\"",
|
||||
"\"Property_9\":\"Property Value of Property_9\"",
|
||||
"\"Property_8\":\"Property Value of Property_8\"",
|
||||
"\"Property_7\":\"Property Value of Property_7\"",
|
||||
"\"Property_6\":\"Property Value of Property_6\"",
|
||||
"\"Property_5\":\"Property Value of Property_5\"",
|
||||
"\"Property_4\":\"Property Value of Property_4\"",
|
||||
"\"Property_3\":\"Property Value of Property_3\"",
|
||||
"\"Property_2\":\"Property Value of Property_2\"",
|
||||
"\"Property_1\":\"Property Value of Property_1\"");
|
||||
} finally {
|
||||
engineProxy.returnConnection();
|
||||
}
|
||||
// verify that the map is correctly retrieved from the database
|
||||
Task retrievedTask = taskService.getTask(createdTask.getId());
|
||||
Map<String, String> customAttributesFromDb = retrievedTask.getCustomAttributeMap();
|
||||
assertThat(customAttributesFromDb).isNotNull();
|
||||
assertThat(customAttributesForCreate).isEqualTo(customAttributesFromDb);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateTask_When_AttachmentIsSpecified() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("L12010");
|
||||
Map<String, String> customAttributesForCreate = createSimpleCustomPropertyMap(27);
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
customAttributesForCreate));
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
assertThat(createdTask.getId()).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
|
||||
// verify that the database content is as expected
|
||||
TaskanaEngineProxy engineProxy = new TaskanaEngineProxy(taskanaEngine);
|
||||
try {
|
||||
SqlSession session = engineProxy.getSqlSession();
|
||||
AttachmentMapper mapper = session.getMapper(AttachmentMapper.class);
|
||||
engineProxy.openConnection();
|
||||
String customProperties =
|
||||
mapper.getCustomAttributesAsString(createdTask.getAttachments().get(0).getId());
|
||||
Set<String> expectedPhrasesSet =
|
||||
IntStream.rangeClosed(1, 27)
|
||||
.mapToObj(String::valueOf)
|
||||
.map(
|
||||
number ->
|
||||
String.format(
|
||||
"\"Property_%s\":\"Property Value of Property_%s\"", number, number))
|
||||
.collect(Collectors.toSet());
|
||||
assertThat(customProperties).contains(expectedPhrasesSet);
|
||||
} finally {
|
||||
engineProxy.returnConnection();
|
||||
}
|
||||
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(readTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(readTask.getAttachments()).isNotNull();
|
||||
assertThat(readTask.getAttachments()).hasSize(1);
|
||||
assertThat(readTask.getAttachments().get(0).getCreated()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getModified()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getModified())
|
||||
.isEqualTo(readTask.getAttachments().get(0).getCreated());
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getId()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getKey()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getType()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getCategory())
|
||||
.isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getDomain()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getClassificationSummary().getServiceLevel())
|
||||
.isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getReceived()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getChannel()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
|
||||
// verify that the map is correctly retrieved from the database
|
||||
Map<String, String> customAttributesFromDb =
|
||||
readTask.getAttachments().get(0).getCustomAttributeMap();
|
||||
assertThat(customAttributesFromDb).isNotNull();
|
||||
assertThat(customAttributesForCreate).isEqualTo(customAttributesFromDb);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateTask_When_MultipleAttachmentsAreSpecified() throws Exception {
|
||||
|
||||
Instant earlierInstant = Instant.parse("2018-01-12T00:00:00Z");
|
||||
Instant laterInstant = Instant.parse("2018-01-15T00:00:00Z");
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("L12010");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
laterInstant,
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
earlierInstant,
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask.getId()).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(readTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(readTask.getAttachments()).isNotNull();
|
||||
assertThat(readTask.getAttachments()).hasSize(2);
|
||||
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified())
|
||||
.isEqualTo(readTask.getAttachments().get(0).getCreated());
|
||||
// assertThat(readTask.getAttachments().get(0).getClassification()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
|
||||
assertThat(readTask.getReceived()).isEqualTo(earlierInstant);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_SetPriorityAndDurationCorrectly_When_UsingClassificationOfAttachment()
|
||||
throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("L12010"); // prio 8, SL P7D
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT", // prio 99, SL P2000D
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"L1060", // prio 1, SL P1D
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask.getId()).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(readTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(readTask.getAttachments()).isNotNull().hasSize(2);
|
||||
assertThat(readTask.getAttachments().get(1).getCreated()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(1).getModified())
|
||||
.isEqualTo(readTask.getAttachments().get(0).getCreated());
|
||||
// assertThat(readTask.getAttachments().get(0).getClassification()).isNotNull();
|
||||
assertThat(readTask.getAttachments().get(0).getObjectReference()).isNotNull();
|
||||
|
||||
assertThat(readTask.getPriority()).isEqualTo(99);
|
||||
|
||||
assertThat(readTask.getDue()).isNotNull();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_AttachmentIsInvalid() throws Exception {
|
||||
|
||||
Consumer<Attachment> testCreateTask =
|
||||
invalidAttachment -> {
|
||||
Task taskWithInvalidAttachment = makeNewTask(taskService);
|
||||
taskWithInvalidAttachment.addAttachment(invalidAttachment);
|
||||
ThrowingCallable call = () -> taskService.createTask(taskWithInvalidAttachment);
|
||||
assertThatThrownBy(call)
|
||||
.describedAs(
|
||||
"Should have thrown an InvalidArgumentException, "
|
||||
+ "because Attachment-ObjRef is null.")
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
};
|
||||
|
||||
testCreateTask.accept(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
null,
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
|
||||
testCreateTask.accept(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference("COMPANY_A", "SYSTEM_B", "INSTANCE_B", "ArchiveId", null),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
|
||||
testCreateTask.accept(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
null,
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
|
||||
testCreateTask.accept(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
null,
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_UseCustomName_For_NewTask() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
newTask.setName("Test Name");
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getName()).isEqualTo("Test Name");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_UseClassificationMetadataFromCorrectDomain_For_NewTask() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
newTask.setName("Test Name");
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getPriority()).isEqualTo(2);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowExceptionIfWorkbasketDoesNotExist() {
|
||||
|
||||
Task newTask = taskService.newTask("UNKNOWN");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask);
|
||||
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void testGetExceptionIfAppendIsNotPermitted() {
|
||||
|
||||
Task newTask = taskService.newTask("GPK_KSC", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask);
|
||||
assertThatThrownBy(call).isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_MandatoryPrimaryObjectReferenceIsNotSetOrIncomplete() {
|
||||
|
||||
Consumer<ObjectReference> testCreateTask =
|
||||
(ObjectReference objectReference) -> {
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
if (objectReference != null) {
|
||||
newTask.setPrimaryObjRef(objectReference);
|
||||
}
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask);
|
||||
assertThatThrownBy(call)
|
||||
.describedAs(
|
||||
"Should have thrown an InvalidArgumentException, because ObjRef-ObjRef is null.")
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
};
|
||||
|
||||
testCreateTask.accept(null);
|
||||
testCreateTask.accept(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", null));
|
||||
testCreateTask.accept(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", null, "1234567"));
|
||||
testCreateTask.accept(createObjectReference(null, "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_SetDomainFromWorkbasket() throws Exception {
|
||||
|
||||
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
|
||||
|
||||
final Workbasket workbasket = workbasketService.getWorkbasket("USER-1-1", "DOMAIN_A");
|
||||
|
||||
Task newTask = taskService.newTask("WBI:100000000000000000000000000000000006");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getCreator())
|
||||
.isEqualTo(taskanaEngine.getCurrentUserContext().getUserid());
|
||||
assertThat(createdTask.getDomain()).isNotNull();
|
||||
assertThat(createdTask.getDomain()).isEqualTo(workbasket.getDomain());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ReadSameTaskObjectAsCreated() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
for (TaskCustomField taskCustomField : TaskCustomField.values()) {
|
||||
newTask.setCustomField(taskCustomField, taskCustomField.name());
|
||||
}
|
||||
newTask.setCustomAttributeMap(createSimpleCustomPropertyMap(5));
|
||||
newTask.setDescription("Description of test task");
|
||||
newTask.setNote("My note");
|
||||
newTask.addAttachment(
|
||||
createExampleAttachment(
|
||||
"DOCTYPE_DEFAULT",
|
||||
createObjectReference(
|
||||
"COMPANY_A",
|
||||
"SYSTEM_B",
|
||||
"INSTANCE_B",
|
||||
"ArchiveId",
|
||||
"12345678901234567890123456789012345678901234567890"),
|
||||
"E-MAIL",
|
||||
Instant.parse("2018-01-15T00:00:00Z"),
|
||||
createSimpleCustomPropertyMap(3)));
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
Task readTask = taskService.getTask(createdTask.getId());
|
||||
|
||||
assertThat(readTask).isEqualTo(createdTask);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_CreateSimpleTask_When_CallbackInfoIsSet() throws Exception {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
Map<String, String> callbackInfo = createSimpleCustomPropertyMap(10);
|
||||
newTask.setCallbackInfo(callbackInfo);
|
||||
Task createdTask = taskService.createTask(newTask);
|
||||
Instant expectedPlanned = moveForwardToWorkingDay(createdTask.getCreated());
|
||||
|
||||
assertThat(createdTask).isNotNull();
|
||||
assertThat(createdTask.getPrimaryObjRef().getValue()).isEqualTo("1234567");
|
||||
assertThat(createdTask.getCreated()).isNotNull();
|
||||
assertThat(createdTask.getModified()).isNotNull();
|
||||
assertThat(createdTask.getBusinessProcessId()).isNotNull();
|
||||
assertThat(createdTask.getClaimed()).isNull();
|
||||
assertThat(createdTask.getCompleted()).isNull();
|
||||
assertThat(createdTask.getModified()).isEqualTo(createdTask.getCreated());
|
||||
assertThat(createdTask.getPlanned()).isEqualTo(expectedPlanned);
|
||||
assertThat(createdTask.getState()).isEqualTo(TaskState.READY);
|
||||
assertThat(createdTask.getParentBusinessProcessId()).isNull();
|
||||
assertThat(createdTask.getPriority()).isEqualTo(2);
|
||||
assertThat(createdTask.isRead()).isFalse();
|
||||
assertThat(createdTask.isTransferred()).isFalse();
|
||||
|
||||
Task retrievedTask = taskService.getTask(createdTask.getId());
|
||||
assertThat(retrievedTask.getCallbackInfo()).isEqualTo(callbackInfo);
|
||||
}
|
||||
|
||||
@Test
|
||||
void should_ThrowException_When_NoUserIdIsSetAndSecurityIsOn() {
|
||||
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("T2100");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_B", "SYSTEM_B", "INSTANCE_B", "VNR", "1234567"));
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask);
|
||||
assertThatThrownBy(call).isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithNonEmptyId() {
|
||||
|
||||
Task newTask = taskService.newTask();
|
||||
((TaskImpl) newTask).setId("TKI:000000000000000000000000000000000000");
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(newTask);
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_UserNotAuthorizedOnWorkbasket() {
|
||||
|
||||
Task task = taskService.newTask("TEAMLEAD-2", "DOMAIN_A");
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
assertThatThrownBy(call).isInstanceOf(NotAuthorizedOnWorkbasketException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_NotThrowNullPointerException_When_CreatingTaskWithoutWorkbasketSummary() {
|
||||
Task task = new TaskImpl();
|
||||
|
||||
ThrowingCallable call = () -> taskService.createTask(task);
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_ThrowException_When_WorkbasketMarkedForDeletion() throws Exception {
|
||||
|
||||
String wbId = "WBI:100000000000000000000000000000000008";
|
||||
Task taskToPreventWorkbasketDeletion = taskService.newTask(wbId);
|
||||
setTaskProperties(taskToPreventWorkbasketDeletion);
|
||||
taskService.createTask(taskToPreventWorkbasketDeletion);
|
||||
taskService.cancelTask(taskToPreventWorkbasketDeletion.getId());
|
||||
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
|
||||
workbasketService.deleteWorkbasket(wbId);
|
||||
Task task = taskService.newTask(wbId);
|
||||
final Task testTask = setTaskProperties(task);
|
||||
assertThatThrownBy(() -> taskService.createTask(testTask))
|
||||
.isInstanceOf(WorkbasketNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithAttachmentClassificationNull() {
|
||||
TaskImpl task = (TaskImpl) makeNewTask(taskService);
|
||||
Attachment attachment = taskService.newAttachment();
|
||||
attachment.setObjectReference(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
task.addAttachment(attachment);
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("Classification of Attachment must not be null.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithAttachmentObjectReferenceNull() {
|
||||
TaskImpl task = (TaskImpl) makeNewTask(taskService);
|
||||
Attachment attachment = taskService.newAttachment();
|
||||
attachment.setClassificationSummary(task.getClassificationSummary());
|
||||
task.addAttachment(attachment);
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("ObjectReference of Attachment must not be null.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithNotExistingAttachmentClassification() {
|
||||
Attachment attachment = taskService.newAttachment();
|
||||
attachment.setObjectReference(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
ClassificationSummary classification =
|
||||
classificationService.newClassification("NOT_EXISTING", "DOMAIN_A", "").asSummary();
|
||||
attachment.setClassificationSummary(classification);
|
||||
|
||||
TaskImpl task = (TaskImpl) makeNewTask(taskService);
|
||||
task.addAttachment(attachment);
|
||||
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(ClassificationNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_CreatingTaskWithMissingAttachmentClassificationKey() {
|
||||
Attachment attachment = taskService.newAttachment();
|
||||
attachment.setObjectReference(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
ClassificationSummaryImpl classification = new ClassificationSummaryImpl();
|
||||
attachment.setClassificationSummary(classification);
|
||||
|
||||
TaskImpl task = (TaskImpl) makeNewTask(taskService);
|
||||
task.addAttachment(attachment);
|
||||
assertThatThrownBy(() -> taskService.createTask(task))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessageContaining("ClassificationKey of Attachment must not be empty.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_FetchAttachmentClassification_When_CreatingTaskWithAttachments() throws Exception {
|
||||
Attachment attachment = taskService.newAttachment();
|
||||
attachment.setObjectReference(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
|
||||
ClassificationSummary classification =
|
||||
classificationService.newClassification("T2000", "DOMAIN_A", "").asSummary();
|
||||
attachment.setClassificationSummary(classification);
|
||||
TaskImpl task = (TaskImpl) makeNewTask(taskService);
|
||||
task.addAttachment(attachment);
|
||||
|
||||
assertThat(classification.getServiceLevel()).isNull();
|
||||
|
||||
task = (TaskImpl) taskService.createTask(task);
|
||||
classification = task.getAttachments().get(0).getClassificationSummary();
|
||||
|
||||
assertThat(classification.getId()).isNotNull();
|
||||
assertThat(classification.getDomain()).isNotNull();
|
||||
assertThat(classification.getServiceLevel()).isNotNull();
|
||||
}
|
||||
|
||||
private Task setTaskProperties(Task task) {
|
||||
task.setClassificationKey("L12010");
|
||||
task.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
return task;
|
||||
}
|
||||
|
||||
private Task makeNewTask(TaskService taskService) {
|
||||
Task newTask = taskService.newTask("USER-1-1", "DOMAIN_A");
|
||||
newTask.setClassificationKey("L12010");
|
||||
newTask.setPrimaryObjRef(
|
||||
createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567"));
|
||||
return newTask;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue