Skip to content

Commit

Permalink
TSK-1824: refactor createTask tests that involve Attachment
Browse files Browse the repository at this point in the history
  • Loading branch information
@ryzheboka
ryzheboka committed Jul 15, 2022
1 parent a0aec39 commit 882ed54
Show file tree
Hide file tree
Showing 2 changed files with 201 additions and 131 deletions.
200 changes: 200 additions & 0 deletions lib/taskana-core/src/test/java/acceptance/task/CreateTaskWithAttachmentAccTest.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,200 @@
package acceptance.task;

import static acceptance.DefaultTestEntities.defaultTestClassification;
import static acceptance.DefaultTestEntities.defaultTestObjectReference;
import static acceptance.DefaultTestEntities.defaultTestWorkbasket;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.util.List;
import java.util.stream.Stream;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.function.ThrowingConsumer;
import testapi.TaskanaInject;
import testapi.TaskanaIntegrationTest;

import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.internal.util.Pair;
import pro.taskana.common.internal.util.Quadruple;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.internal.builder.TaskAttachmentBuilder;
import pro.taskana.task.internal.builder.TaskBuilder;
import pro.taskana.workbasket.api.WorkbasketPermission;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
import pro.taskana.workbasket.internal.builder.WorkbasketAccessItemBuilder;

/**
* Acceptance test for all "create task" scenarios that involve {@linkplain Attachment Attachments}.
*/
@TaskanaIntegrationTest
class CreateTaskWithAttachmentAccTest {
@TaskanaInject TaskService taskService;
@TaskanaInject WorkbasketService workbasketService;
@TaskanaInject ClassificationService classificationService;

ClassificationSummary defaultClassificationSummary;
WorkbasketSummary defaultWorkbasketSummary;
ObjectReference defaultObjectReference;
Attachment defaultAttachment;
Task defaultTaskWithAttachment;

@WithAccessId(user = "businessadmin")
@BeforeAll
void setup() throws Exception {
defaultClassificationSummary =
defaultTestClassification()
.serviceLevel("P2D")
.buildAndStoreAsSummary(classificationService);
defaultWorkbasketSummary = defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);

WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
.workbasketId(defaultWorkbasketSummary.getId())
.accessId("user-1-1")
.permission(WorkbasketPermission.OPEN)
.permission(WorkbasketPermission.READ)
.permission(WorkbasketPermission.APPEND)
.buildAndStore(workbasketService);
defaultObjectReference = defaultTestObjectReference().build();
defaultAttachment =
TaskAttachmentBuilder.newAttachment()
.classificationSummary(defaultClassificationSummary)
.objectReference(defaultObjectReference)
.build();
defaultTaskWithAttachment =
TaskBuilder.newTask()
.primaryObjRef(defaultObjectReference)
.workbasketSummary(defaultWorkbasketSummary)
.classificationSummary(defaultClassificationSummary)
.attachments(defaultAttachment)
.buildAndStore(taskService, "user-1-1");
}

@WithAccessId(user = "user-1-1")
@Test
void should_SetTaskIdOfAttachmentCorrectly_WhenCopyingAttachment() throws Exception {
Attachment copiedAttachment =
taskService.getTask(defaultTaskWithAttachment.getId()).getAttachments().get(0).copy();
Task taskToCreate = taskService.newTask(defaultWorkbasketSummary.getId());
taskToCreate.setClassificationKey(defaultClassificationSummary.getKey());
taskToCreate.setPrimaryObjRef(defaultObjectReference);
taskToCreate.addAttachment(copiedAttachment);
Task result = taskService.createTask(taskToCreate);

assertThat(result.getAttachments().get(0).getTaskId()).isEqualTo(result.getId());
}

@WithAccessId(user = "user-1-1")
@Test
void should_FetchAttachmentClassification_When_CreatingTaskWithAttachments() throws Exception {
Attachment attachment = taskService.newAttachment();
attachment.setObjectReference(defaultObjectReference);
ClassificationSummary classification =
classificationService
.newClassification(
defaultClassificationSummary.getKey(),
defaultClassificationSummary.getDomain(),
defaultClassificationSummary.getType())
.asSummary();
attachment.setClassificationSummary(classification);
Task taskToCreate = taskService.newTask(defaultWorkbasketSummary.getId());
taskToCreate.setClassificationKey(defaultClassificationSummary.getKey());
taskToCreate.setPrimaryObjRef(defaultObjectReference);
taskToCreate.addAttachment(attachment);
taskToCreate = taskService.createTask(taskToCreate);

classification = taskToCreate.getAttachments().get(0).getClassificationSummary();
assertThat(classification).isEqualTo(defaultClassificationSummary);
}

@WithAccessId(user = "user-1-1")
@TestFactory
Stream<DynamicTest>
should_ThrowException_When_CreatingTaskWithInvalidObjectReferenceOfAttachment() {
ObjectReference objRefTypeNull =
taskService.newObjectReference("Company", "System", "Instance", null, "Value");
ObjectReference objRefValueNull =
taskService.newObjectReference("Company", "System", "Instance", "Type", null);
ObjectReference objRefCompanyNull =
taskService.newObjectReference(null, "System", "Instance", "Type", "Value");
List<Pair<String, ObjectReference>> valuesForTests =
List.of(
Pair.of("ObjRef is null", null),
Pair.of("Type of objRef is null", objRefTypeNull),
Pair.of("Value of objRef is null", objRefValueNull),
Pair.of("Company of objRef is null", objRefCompanyNull));

ThrowingConsumer<Pair<String, ObjectReference>> test =
p -> {
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
task.setClassificationKey(defaultClassificationSummary.getKey());
task.setPrimaryObjRef(defaultObjectReference);
Attachment attachment = taskService.newAttachment();
attachment.setClassificationSummary(defaultClassificationSummary);
attachment.setObjectReference(p.getRight());
task.addAttachment(attachment);
assertThatThrownBy(() -> taskService.createTask(task))
.isInstanceOf(InvalidArgumentException.class);
};

return DynamicTest.stream(valuesForTests.iterator(), Pair::getLeft, test);
}

@WithAccessId(user = "user-1-1")
@TestFactory
Stream<DynamicTest>
should_ThrowException_When_CreatingTaskWithInvalidClassificationOfAttachment() {
Classification nonExistingClassification =
classificationService.newClassification(
"123key345", defaultWorkbasketSummary.getDomain(), "non existing type");
Classification classificationWithoutKey =
classificationService.newClassification(
null, defaultClassificationSummary.getDomain(), defaultClassificationSummary.getType());
List<Quadruple<String, Classification, String, Class<?>>> valuesForTests =
List.of(
Quadruple.of(
"Classification is null",
null,
"Classification of Attachment must not be null",
InvalidArgumentException.class),
Quadruple.of(
"Classification doesn't exist",
nonExistingClassification,
"Classification with key '123key345' and domain '"
+ defaultWorkbasketSummary.getDomain()
+ "' could not be found",
ClassificationNotFoundException.class),
Quadruple.of(
"Classification has no key",
classificationWithoutKey,
"ClassificationKey of Attachment must not be empty.",
InvalidArgumentException.class));

ThrowingConsumer<Quadruple<String, Classification, String, Class<?>>> test =
q -> {
Task task = taskService.newTask(defaultWorkbasketSummary.getId());
task.setClassificationKey(defaultClassificationSummary.getKey());
task.setPrimaryObjRef(defaultObjectReference);
Attachment attachment = taskService.newAttachment();
attachment.setClassificationSummary(q.getSecond());
attachment.setObjectReference(defaultObjectReference);
task.addAttachment(attachment);
assertThatThrownBy(() -> taskService.createTask(task))
.isInstanceOf(q.getFourth())
.hasMessageContaining(q.getThird());
};

return DynamicTest.stream(valuesForTests.iterator(), Quadruple::getFirst, test);
}
}
132 changes: 1 addition & 131 deletions lib/taskana-core/src/test/java/acceptance/task/create/CreateTaskAccTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,9 +21,6 @@
import org.junit.jupiter.api.extension.ExtendWith;

import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.classification.internal.models.ClassificationSummaryImpl;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
import pro.taskana.common.test.security.JaasExtension;
Expand Down Expand Up @@ -534,65 +531,6 @@ void testPrioDurationOfTaskFromAttachmentsAtCreate() throws Exception {
assertThat(readTask.getDue()).isEqualTo(expDue);
}

@WithAccessId(user = "user-1-1")
@Test
void testThrowsExceptionIfAttachmentIsInvalid() 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 testUseCustomNameIfSetForNewTask() throws Exception {
Expand Down Expand Up @@ -824,6 +762,7 @@ void testCreateTaskWithWorkbasketMarkedForDeletion() throws Exception {
.isInstanceOf(WorkbasketNotFoundException.class);
}

// Rewritten
@WithAccessId(user = "user-1-1")
@Test
void should_ThrowException_When_CreatingTaskWithAttachmentClassificationNull() {
Expand All @@ -838,75 +777,6 @@ void should_ThrowException_When_CreatingTaskWithAttachmentClassificationNull() {
.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(
Expand Down

0 comments on commit 882ed54

Please sign in to comment.