TSK-1794: Updated CreateClassificationAccTest to use Test-API
Cleaned up Test cases and improved quality. Transfered one test method from CreateClassificationServiceAccTest to UpdateClassificationAccTest.
This commit is contained in:
Yakup Ensar Evli
Mustapha Zorgati
parent
a5c8cd3c70
commit
3278137977
|
|
@ -3,295 +3,313 @@ package acceptance.classification;
|
||||||
import static org.assertj.core.api.Assertions.assertThat;
|
import static org.assertj.core.api.Assertions.assertThat;
|
||||||
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
||||||
|
|
||||||
import acceptance.AbstractAccTest;
|
import acceptance.DefaultTestEntities;
|
||||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
import java.time.Instant;
|
||||||
|
import java.util.Arrays;
|
||||||
|
import java.util.Iterator;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.concurrent.atomic.AtomicInteger;
|
||||||
|
import java.util.function.Consumer;
|
||||||
|
import java.util.stream.Stream;
|
||||||
|
import org.junit.jupiter.api.DynamicTest;
|
||||||
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.Test;
|
||||||
|
import org.junit.jupiter.api.TestFactory;
|
||||||
import org.junit.jupiter.api.TestTemplate;
|
import org.junit.jupiter.api.TestTemplate;
|
||||||
import org.junit.jupiter.api.extension.ExtendWith;
|
import org.junit.jupiter.api.function.ThrowingConsumer;
|
||||||
|
import testapi.TaskanaInject;
|
||||||
|
import testapi.TaskanaIntegrationTest;
|
||||||
|
|
||||||
import pro.taskana.classification.api.ClassificationService;
|
import pro.taskana.classification.api.ClassificationService;
|
||||||
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
|
import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistException;
|
||||||
import pro.taskana.classification.api.exceptions.MalformedServiceLevelException;
|
import pro.taskana.classification.api.exceptions.MalformedServiceLevelException;
|
||||||
import pro.taskana.classification.api.models.Classification;
|
import pro.taskana.classification.api.models.Classification;
|
||||||
|
import pro.taskana.classification.api.models.ClassificationSummary;
|
||||||
import pro.taskana.classification.internal.models.ClassificationImpl;
|
import pro.taskana.classification.internal.models.ClassificationImpl;
|
||||||
|
import pro.taskana.common.api.TaskanaRole;
|
||||||
|
import pro.taskana.common.api.TimeInterval;
|
||||||
import pro.taskana.common.api.exceptions.DomainNotFoundException;
|
import pro.taskana.common.api.exceptions.DomainNotFoundException;
|
||||||
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
import pro.taskana.common.api.exceptions.InvalidArgumentException;
|
||||||
import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
import pro.taskana.common.api.exceptions.MismatchedRoleException;
|
||||||
import pro.taskana.common.internal.util.IdGenerator;
|
import pro.taskana.common.internal.util.Pair;
|
||||||
import pro.taskana.common.test.security.JaasExtension;
|
|
||||||
import pro.taskana.common.test.security.WithAccessId;
|
import pro.taskana.common.test.security.WithAccessId;
|
||||||
|
|
||||||
/** Acceptance test for all "create classification" scenarios. */
|
/** Acceptance test for all "create classification" scenarios. */
|
||||||
@ExtendWith(JaasExtension.class)
|
@TaskanaIntegrationTest
|
||||||
class CreateClassificationAccTest extends AbstractAccTest {
|
class CreateClassificationAccTest {
|
||||||
|
@TaskanaInject ClassificationService classificationService;
|
||||||
private static final ClassificationService CLASSIFICATION_SERVICE =
|
|
||||||
taskanaEngine.getClassificationService();
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateMasterClassification() throws Exception {
|
void should_OnlyCreateOneClassification_WhenCreatingMasterClassification() throws Exception {
|
||||||
final long amountOfClassificationsBefore =
|
Classification classification = classificationService.newClassification("Key0", "", "TASK");
|
||||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key0", "", "TASK");
|
|
||||||
classification.setIsValidInDomain(true);
|
|
||||||
classification.setServiceLevel("P1D");
|
|
||||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
|
||||||
|
|
||||||
// check only 1 created
|
classification = classificationService.createClassification(classification);
|
||||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 1);
|
|
||||||
|
|
||||||
classification = CLASSIFICATION_SERVICE.getClassification(classification.getId());
|
List<ClassificationSummary> classifications =
|
||||||
assertThat(classification).isNotNull();
|
classificationService.createClassificationQuery().keyIn("Key0").list();
|
||||||
|
assertThat(classifications).containsExactly(classification.asSummary());
|
||||||
assertThat(classification.getCreated()).isNotNull();
|
|
||||||
assertThat(classification.getModified()).isNotNull();
|
|
||||||
assertThat(classification.getId()).isNotNull();
|
|
||||||
assertThat(classification.getIsValidInDomain()).isFalse();
|
|
||||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithMasterCopy() throws Exception {
|
void should_CreateMasterClassification_WhenCreatingClassificationWithDomain() throws Exception {
|
||||||
final long countClassificationsBefore =
|
|
||||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
Classification classification =
|
Classification classification =
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key1", "DOMAIN_A", "TASK");
|
classificationService.newClassification("Key1", "DOMAIN_A", "TASK");
|
||||||
classification.setIsValidInDomain(true);
|
|
||||||
classification.setServiceLevel("P1D");
|
|
||||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
|
||||||
|
|
||||||
// Check returning one is the "original"
|
classificationService.createClassification(classification);
|
||||||
Classification createdClassification =
|
|
||||||
CLASSIFICATION_SERVICE.getClassification(classification.getId());
|
|
||||||
assertThat(classification).isNotNull();
|
|
||||||
assertThat(classification.getCreated()).isNotNull();
|
|
||||||
assertThat(classification.getModified()).isNotNull();
|
|
||||||
assertThat(classification.getId()).isNotNull();
|
|
||||||
assertThat(classification.getIsValidInDomain()).isTrue();
|
|
||||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
|
||||||
assertThat(createdClassification.getDomain()).isEqualTo("DOMAIN_A");
|
|
||||||
assertThat(createdClassification.getKey()).isEqualTo("Key1");
|
|
||||||
|
|
||||||
// Check 2 new created
|
ClassificationImpl expectedMasterClassification =
|
||||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
(ClassificationImpl) classification.copy("Key1");
|
||||||
assertThat(amountOfClassificationsAfter).isEqualTo(countClassificationsBefore + 2);
|
expectedMasterClassification.setDomain("");
|
||||||
|
|
||||||
// Check main
|
List<ClassificationSummary> classifications =
|
||||||
classification = CLASSIFICATION_SERVICE.getClassification(classification.getId());
|
classificationService.createClassificationQuery().keyIn("Key1").list();
|
||||||
assertThat(classification).isNotNull();
|
|
||||||
assertThat(classification.getCreated()).isNotNull();
|
|
||||||
assertThat(classification.getModified()).isNotNull();
|
|
||||||
assertThat(classification.getId()).isNotNull();
|
|
||||||
assertThat(classification.getIsValidInDomain()).isTrue();
|
|
||||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
|
||||||
|
|
||||||
// Check master-copy
|
assertThat(classifications)
|
||||||
classification = CLASSIFICATION_SERVICE.getClassification(classification.getKey(), "");
|
.allMatch(c -> c.getId() != null)
|
||||||
assertThat(classification).isNotNull();
|
.usingRecursiveFieldByFieldElementComparatorIgnoringFields("id")
|
||||||
assertThat(classification.getCreated()).isNotNull();
|
.containsExactlyInAnyOrder(
|
||||||
assertThat(classification.getModified()).isNotNull();
|
classification.asSummary(), expectedMasterClassification.asSummary());
|
||||||
assertThat(classification.getId()).isNotNull();
|
|
||||||
assertThat(classification.getIsValidInDomain()).isFalse();
|
|
||||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithExistingMaster() throws Exception {
|
void should_NotCreateMasterClassification_When_OneAlreadyExists() throws Exception {
|
||||||
|
@SuppressWarnings("unused")
|
||||||
|
Classification masterClassification =
|
||||||
|
DefaultTestEntities.defaultTestClassification()
|
||||||
|
.key("Key2")
|
||||||
|
.domain("")
|
||||||
|
.type("TASK")
|
||||||
|
.buildAndStore(classificationService);
|
||||||
|
|
||||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key0815", "", "TASK");
|
Instant before = Instant.now();
|
||||||
classification.setServiceLevel("P1D");
|
// Sometimes the test execution is too fast. Therefore, we have to slow it down.
|
||||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
Thread.sleep(10);
|
||||||
|
|
||||||
long amountOfClassificationsBefore = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
Classification expected =
|
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key0815", "DOMAIN_B", "TASK");
|
|
||||||
expected.setServiceLevel("P1D");
|
|
||||||
Classification actual = CLASSIFICATION_SERVICE.createClassification(expected);
|
|
||||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
|
|
||||||
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 1);
|
|
||||||
assertThat(actual).isSameAs(expected);
|
|
||||||
assertThat(actual.getIsValidInDomain()).isTrue();
|
|
||||||
}
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
|
||||||
@Test
|
|
||||||
void testCreateChildInDomainAndCopyInMaster() throws Exception {
|
|
||||||
Classification parent = CLASSIFICATION_SERVICE.newClassification("Key0816", "DOMAIN_A", "TASK");
|
|
||||||
parent.setServiceLevel("P1D");
|
|
||||||
Classification actualParent = CLASSIFICATION_SERVICE.createClassification(parent);
|
|
||||||
assertThat(actualParent).isNotNull();
|
|
||||||
|
|
||||||
final long amountOfClassificationsBefore =
|
|
||||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
Classification child = CLASSIFICATION_SERVICE.newClassification("Key0817", "DOMAIN_A", "TASK");
|
|
||||||
child.setParentId(actualParent.getId());
|
|
||||||
child.setParentKey(actualParent.getKey());
|
|
||||||
child.setServiceLevel("P1D");
|
|
||||||
Classification actualChild = CLASSIFICATION_SERVICE.createClassification(child);
|
|
||||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
|
||||||
|
|
||||||
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 2);
|
|
||||||
assertThat(actualChild).isNotNull();
|
|
||||||
}
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
|
||||||
@Test
|
|
||||||
void should_ThrowException_When_TryingToCreateClassificationWithNegativeServiceLevel() {
|
|
||||||
Classification classification =
|
Classification classification =
|
||||||
CLASSIFICATION_SERVICE.newClassification("someKey234", "DOMAIN_A", "TASK");
|
classificationService.newClassification("Key2", "DOMAIN_B", "TASK");
|
||||||
classification.setServiceLevel("P-1D");
|
classificationService.createClassification(classification);
|
||||||
|
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
List<ClassificationSummary> classifications =
|
||||||
.isInstanceOf(MalformedServiceLevelException.class);
|
classificationService
|
||||||
|
.createClassificationQuery()
|
||||||
|
.keyIn("Key2")
|
||||||
|
.modifiedWithin(new TimeInterval(before, null))
|
||||||
|
.list();
|
||||||
|
|
||||||
|
assertThat(classifications).containsExactly(classification.asSummary());
|
||||||
|
}
|
||||||
|
|
||||||
|
@WithAccessId(user = "businessadmin")
|
||||||
|
@TestFactory
|
||||||
|
Stream<DynamicTest> should_CreateChildClassification() throws Exception {
|
||||||
|
ClassificationSummary parentClassification =
|
||||||
|
DefaultTestEntities.defaultTestClassification()
|
||||||
|
.key("Key3")
|
||||||
|
.domain("DOMAIN_A")
|
||||||
|
.type("TASK")
|
||||||
|
.buildAndStoreAsSummary(classificationService);
|
||||||
|
|
||||||
|
List<Pair<String, Consumer<Classification>>> setterList =
|
||||||
|
List.of(
|
||||||
|
Pair.of("parent key", p -> p.setParentKey(parentClassification.getKey())),
|
||||||
|
Pair.of("parent id", p -> p.setParentId(parentClassification.getId())));
|
||||||
|
|
||||||
|
AtomicInteger i = new AtomicInteger();
|
||||||
|
|
||||||
|
ThrowingConsumer<Pair<String, Consumer<Classification>>> test =
|
||||||
|
pair -> {
|
||||||
|
Classification childClassification =
|
||||||
|
classificationService.newClassification("Key3_" + i.get(), "DOMAIN_A", "TASK");
|
||||||
|
pair.getRight().accept(childClassification);
|
||||||
|
|
||||||
|
classificationService.createClassification(childClassification);
|
||||||
|
|
||||||
|
List<ClassificationSummary> classifications =
|
||||||
|
classificationService
|
||||||
|
.createClassificationQuery()
|
||||||
|
.keyIn("Key3_" + i.getAndIncrement())
|
||||||
|
.list();
|
||||||
|
|
||||||
|
assertThat(classifications)
|
||||||
|
.allMatch(c -> c.getId() != null)
|
||||||
|
.contains(childClassification.asSummary());
|
||||||
|
};
|
||||||
|
|
||||||
|
return DynamicTest.stream(
|
||||||
|
setterList.iterator(), p -> String.format("for %s", p.getLeft()), test);
|
||||||
|
}
|
||||||
|
|
||||||
|
@WithAccessId(user = "businessadmin")
|
||||||
|
@TestFactory
|
||||||
|
Stream<DynamicTest>
|
||||||
|
should_ThrowException_When_TryingToCreateClassificationWithInvalidServiceLevel() {
|
||||||
|
Iterator<String> iterator = Arrays.asList("P-1D", "abc").iterator();
|
||||||
|
ThrowingConsumer<String> test =
|
||||||
|
invalidServiceLevel -> {
|
||||||
|
Classification classification =
|
||||||
|
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "TASK");
|
||||||
|
classification.setServiceLevel(invalidServiceLevel);
|
||||||
|
MalformedServiceLevelException expectedException =
|
||||||
|
new MalformedServiceLevelException(invalidServiceLevel, "KeyErrCreation", "DOMAIN_A");
|
||||||
|
|
||||||
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(MalformedServiceLevelException.class)
|
||||||
|
.usingRecursiveComparison()
|
||||||
|
.isEqualTo(expectedException);
|
||||||
|
};
|
||||||
|
|
||||||
|
return DynamicTest.stream(iterator, c -> String.format("for '%s'", c), test);
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithInvalidValues() {
|
void should_ThrowException_When_TryingToCreateClassificationWithInvalidKey() {
|
||||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
Classification classificationWithNullKey =
|
||||||
|
classificationService.newClassification(null, "DOMAIN_A", "TASK");
|
||||||
|
|
||||||
// Check key NULL
|
assertThatThrownBy(() -> classificationService.createClassification(classificationWithNullKey))
|
||||||
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
|
.hasMessage("Classification must contain a key");
|
||||||
|
}
|
||||||
|
|
||||||
|
@WithAccessId(user = "businessadmin")
|
||||||
|
@Test
|
||||||
|
void should_ThrowException_When_TryingToCreateClassificationWithInvalidDomain() {
|
||||||
Classification classification =
|
Classification classification =
|
||||||
CLASSIFICATION_SERVICE.newClassification(null, "DOMAIN_A", "TASK");
|
classificationService.newClassification("KeyErrCreation", "UNKNOWN_DOMAIN", "TASK");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
DomainNotFoundException expectedException = new DomainNotFoundException("UNKNOWN_DOMAIN");
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
|
||||||
|
|
||||||
// Check invalid ServiceLevel
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(DomainNotFoundException.class)
|
||||||
Classification classification2 =
|
.usingRecursiveComparison()
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key2", "DOMAIN_B", "TASK");
|
.isEqualTo(expectedException);
|
||||||
classification2.setServiceLevel("abc");
|
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification2))
|
|
||||||
.isInstanceOf(MalformedServiceLevelException.class);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationAlreadyExisting() throws Exception {
|
void should_ThrowException_TryingToCreateClassificationWithInvalidType() {
|
||||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key3", "", "TASK");
|
|
||||||
classification.setServiceLevel("P1D");
|
|
||||||
Classification classificationCreated =
|
|
||||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classificationCreated))
|
|
||||||
.isInstanceOf(ClassificationAlreadyExistException.class);
|
|
||||||
}
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
|
||||||
@Test
|
|
||||||
void testCreateClassificationInUnknownDomain() {
|
|
||||||
Classification classification =
|
Classification classification =
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key3", "UNKNOWN_DOMAIN", "TASK");
|
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "UNKNOWN_TYPE");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
|
||||||
.isInstanceOf(DomainNotFoundException.class);
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
|
.hasMessage(
|
||||||
|
"Given classification type "
|
||||||
|
+ "UNKNOWN_TYPE"
|
||||||
|
+ " is not valid according to the configuration.");
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationOfUnknownType() {
|
void should_ThrowException_TryingToCreateClassificationWithInvalidCategory() {
|
||||||
Classification classification =
|
Classification classification =
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key3", "DOMAIN_A", "UNKNOWN_TYPE");
|
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "TASK");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
|
||||||
}
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
|
||||||
@Test
|
|
||||||
void testCreateClassificationOfUnknownCategory() {
|
|
||||||
Classification classification =
|
|
||||||
CLASSIFICATION_SERVICE.newClassification("Key4", "DOMAIN_A", "TASK");
|
|
||||||
classification.setCategory("UNKNOWN_CATEGORY");
|
classification.setCategory("UNKNOWN_CATEGORY");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
|
.hasMessage(
|
||||||
|
"Given classification category "
|
||||||
|
+ "UNKNOWN_CATEGORY"
|
||||||
|
+ " with type TASK is not valid according to the configuration.");
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithInvalidParentId() {
|
void should_ThrowException_TryingToCreateClassificationWithInvalidParentKey() {
|
||||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key5", "", "TASK");
|
Classification classification =
|
||||||
classification.setParentId("ID WHICH CANT BE FOUND");
|
classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
classification.setParentKey("UNKNOWN_KEY");
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
|
||||||
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
|
.hasMessage("Parent classification could not be found.");
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithInvalidParentKey() {
|
void should_ThrowException_TryingToCreateClassificationWithInvalidParentId() {
|
||||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key5", "", "TASK");
|
Classification classification = classificationService.newClassification("KeyErr", "", "TASK");
|
||||||
classification.setParentKey("KEY WHICH CANT BE FOUND");
|
classification.setParentId("UNKNOWN_ID");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
|
.hasMessage("Parent classification could not be found.");
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testCreateClassificationWithExplicitId() {
|
void should_ThrowException_TryingToCreateClassificationWithExplicitId() {
|
||||||
ClassificationImpl classification =
|
ClassificationImpl classification =
|
||||||
(ClassificationImpl) CLASSIFICATION_SERVICE.newClassification("Key0818", "", "TASK");
|
(ClassificationImpl) classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||||
classification.setId("EXPLICIT ID");
|
classification.setId("EXPLICIT ID");
|
||||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
|
||||||
.isInstanceOf(InvalidArgumentException.class);
|
|
||||||
}
|
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
@Test
|
.isInstanceOf(InvalidArgumentException.class)
|
||||||
void should_BeAbleToCreateNewClassification_When_ClassificationCopy() throws Exception {
|
.hasMessage("ClassificationId should be null on creation");
|
||||||
ClassificationImpl oldClassification =
|
|
||||||
(ClassificationImpl) CLASSIFICATION_SERVICE.getClassification("T2100", "DOMAIN_B");
|
|
||||||
Classification newClassification = oldClassification.copy("T9949");
|
|
||||||
|
|
||||||
newClassification = CLASSIFICATION_SERVICE.createClassification(newClassification);
|
|
||||||
|
|
||||||
assertThat(newClassification.getId()).isNotNull();
|
|
||||||
assertThat(newClassification.getId()).isNotEqualTo(oldClassification.getId());
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "taskadmin")
|
@WithAccessId(user = "taskadmin")
|
||||||
@WithAccessId(user = "user-1-1")
|
@WithAccessId(user = "user-1-1")
|
||||||
@TestTemplate
|
@TestTemplate
|
||||||
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
|
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin(WithAccessId accessId) {
|
||||||
ClassificationImpl classification =
|
Classification classification =
|
||||||
(ClassificationImpl) CLASSIFICATION_SERVICE.newClassification("newKey718", "", "TASK");
|
classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||||
|
MismatchedRoleException expectedException =
|
||||||
|
new MismatchedRoleException(accessId.user(), TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
|
||||||
|
|
||||||
ThrowingCallable createClassificationCall =
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
() -> {
|
.isInstanceOf(MismatchedRoleException.class)
|
||||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
.usingRecursiveComparison()
|
||||||
};
|
.isEqualTo(expectedException);
|
||||||
|
|
||||||
assertThatThrownBy(createClassificationCall).isInstanceOf(NotAuthorizedException.class);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "admin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void should_SetDefaultServiceLevel_When_TryingToCreateClassificationWithMissingServiceLevel()
|
void should_ThrowException_WhenClassificationWithKeyAlreadyExisting() throws Exception {
|
||||||
throws Exception {
|
String existingKey = "Key4";
|
||||||
Classification classification =
|
DefaultTestEntities.defaultTestClassification()
|
||||||
CLASSIFICATION_SERVICE.newClassification("newKey718", "", "TASK");
|
.key(existingKey)
|
||||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
.buildAndStore(classificationService);
|
||||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
ClassificationAlreadyExistException expectedException =
|
||||||
|
new ClassificationAlreadyExistException(existingKey, "DOMAIN_A");
|
||||||
|
|
||||||
classification = CLASSIFICATION_SERVICE.newClassification("newKey71", "", "TASK");
|
Classification classification =
|
||||||
|
classificationService.newClassification(existingKey, "DOMAIN_A", "TASK");
|
||||||
|
|
||||||
|
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||||
|
.isInstanceOf(ClassificationAlreadyExistException.class)
|
||||||
|
.usingRecursiveComparison()
|
||||||
|
.isEqualTo(expectedException);
|
||||||
|
}
|
||||||
|
|
||||||
|
@WithAccessId(user = "businessadmin")
|
||||||
|
@Test
|
||||||
|
void should_SetDefaultServiceLevel_When_TryingToCreateClassificationWithEmptyServiceLevel()
|
||||||
|
throws Exception {
|
||||||
|
Classification classification = classificationService.newClassification("Key5", "", "TASK");
|
||||||
classification.setServiceLevel("");
|
classification.setServiceLevel("");
|
||||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
|
||||||
|
classification = classificationService.createClassification(classification);
|
||||||
|
|
||||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||||
}
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "admin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void should_SetDefaultServiceLevel_When_TryingToUpdateClassificationWithMissingServiceLevel()
|
void should_SetDefaultValues_When_CreatingClassificationWithoutSpecificValues() throws Exception {
|
||||||
throws Exception {
|
Classification classification = classificationService.newClassification("Key6", "", "TASK");
|
||||||
Classification classification =
|
classification = classificationService.createClassification(classification);
|
||||||
CLASSIFICATION_SERVICE.getClassification("CLI:000000000000000000000000000000000001");
|
|
||||||
classification.setServiceLevel(null);
|
|
||||||
classification = CLASSIFICATION_SERVICE.updateClassification(classification);
|
|
||||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
|
||||||
|
|
||||||
classification.setServiceLevel("");
|
|
||||||
classification = CLASSIFICATION_SERVICE.updateClassification(classification);
|
|
||||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||||
|
assertThat(classification.getId()).isNotNull();
|
||||||
|
assertThat(classification.getId()).isNotEmpty();
|
||||||
|
assertThat(classification.getCreated()).isNotNull();
|
||||||
|
assertThat(classification.getModified()).isNotNull();
|
||||||
|
assertThat(classification.getParentId()).isEmpty();
|
||||||
|
assertThat(classification.getParentKey()).isEmpty();
|
||||||
|
assertThat(classification.getIsValidInDomain()).isFalse();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -35,6 +35,22 @@ class UpdateClassificationAccTest extends AbstractAccTest {
|
||||||
private final ClassificationService classificationService =
|
private final ClassificationService classificationService =
|
||||||
taskanaEngine.getClassificationService();
|
taskanaEngine.getClassificationService();
|
||||||
|
|
||||||
|
@WithAccessId(user = "admin")
|
||||||
|
@Test
|
||||||
|
void should_SetDefaultServiceLevel_When_TryingToUpdateClassificationWithMissingServiceLevel()
|
||||||
|
throws Exception {
|
||||||
|
Classification classification =
|
||||||
|
classificationService.newClassification("Key1230", "DOMAIN_A", "TASK");
|
||||||
|
classification.setServiceLevel("P1D");
|
||||||
|
classification = classificationService.createClassification(classification);
|
||||||
|
classification.setServiceLevel(null);
|
||||||
|
classification = classificationService.updateClassification(classification);
|
||||||
|
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||||
|
classification.setServiceLevel("");
|
||||||
|
classification = classificationService.updateClassification(classification);
|
||||||
|
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||||
|
}
|
||||||
|
|
||||||
@WithAccessId(user = "businessadmin")
|
@WithAccessId(user = "businessadmin")
|
||||||
@Test
|
@Test
|
||||||
void testUpdateClassification() throws Exception {
|
void testUpdateClassification() throws Exception {
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue