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.assertThatThrownBy;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import acceptance.DefaultTestEntities;
|
||||
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.TestFactory;
|
||||
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.exceptions.ClassificationAlreadyExistException;
|
||||
import pro.taskana.classification.api.exceptions.MalformedServiceLevelException;
|
||||
import pro.taskana.classification.api.models.Classification;
|
||||
import pro.taskana.classification.api.models.ClassificationSummary;
|
||||
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.InvalidArgumentException;
|
||||
import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
||||
import pro.taskana.common.internal.util.IdGenerator;
|
||||
import pro.taskana.common.test.security.JaasExtension;
|
||||
import pro.taskana.common.api.exceptions.MismatchedRoleException;
|
||||
import pro.taskana.common.internal.util.Pair;
|
||||
import pro.taskana.common.test.security.WithAccessId;
|
||||
|
||||
/** Acceptance test for all "create classification" scenarios. */
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class CreateClassificationAccTest extends AbstractAccTest {
|
||||
|
||||
private static final ClassificationService CLASSIFICATION_SERVICE =
|
||||
taskanaEngine.getClassificationService();
|
||||
@TaskanaIntegrationTest
|
||||
class CreateClassificationAccTest {
|
||||
@TaskanaInject ClassificationService classificationService;
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateMasterClassification() throws Exception {
|
||||
final long amountOfClassificationsBefore =
|
||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key0", "", "TASK");
|
||||
classification.setIsValidInDomain(true);
|
||||
classification.setServiceLevel("P1D");
|
||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
void should_OnlyCreateOneClassification_WhenCreatingMasterClassification() throws Exception {
|
||||
Classification classification = classificationService.newClassification("Key0", "", "TASK");
|
||||
|
||||
// check only 1 created
|
||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
||||
assertThat(amountOfClassificationsAfter).isEqualTo(amountOfClassificationsBefore + 1);
|
||||
classification = classificationService.createClassification(classification);
|
||||
|
||||
classification = CLASSIFICATION_SERVICE.getClassification(classification.getId());
|
||||
assertThat(classification).isNotNull();
|
||||
|
||||
assertThat(classification.getCreated()).isNotNull();
|
||||
assertThat(classification.getModified()).isNotNull();
|
||||
assertThat(classification.getId()).isNotNull();
|
||||
assertThat(classification.getIsValidInDomain()).isFalse();
|
||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
||||
List<ClassificationSummary> classifications =
|
||||
classificationService.createClassificationQuery().keyIn("Key0").list();
|
||||
assertThat(classifications).containsExactly(classification.asSummary());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationWithMasterCopy() throws Exception {
|
||||
final long countClassificationsBefore =
|
||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
||||
void should_CreateMasterClassification_WhenCreatingClassificationWithDomain() throws Exception {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.newClassification("Key1", "DOMAIN_A", "TASK");
|
||||
classification.setIsValidInDomain(true);
|
||||
classification.setServiceLevel("P1D");
|
||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
classificationService.newClassification("Key1", "DOMAIN_A", "TASK");
|
||||
|
||||
// Check returning one is the "original"
|
||||
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");
|
||||
classificationService.createClassification(classification);
|
||||
|
||||
// Check 2 new created
|
||||
long amountOfClassificationsAfter = CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
||||
assertThat(amountOfClassificationsAfter).isEqualTo(countClassificationsBefore + 2);
|
||||
ClassificationImpl expectedMasterClassification =
|
||||
(ClassificationImpl) classification.copy("Key1");
|
||||
expectedMasterClassification.setDomain("");
|
||||
|
||||
// Check main
|
||||
classification = 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);
|
||||
List<ClassificationSummary> classifications =
|
||||
classificationService.createClassificationQuery().keyIn("Key1").list();
|
||||
|
||||
// Check master-copy
|
||||
classification = CLASSIFICATION_SERVICE.getClassification(classification.getKey(), "");
|
||||
assertThat(classification).isNotNull();
|
||||
assertThat(classification.getCreated()).isNotNull();
|
||||
assertThat(classification.getModified()).isNotNull();
|
||||
assertThat(classification.getId()).isNotNull();
|
||||
assertThat(classification.getIsValidInDomain()).isFalse();
|
||||
assertThat(classification.getId()).startsWith(IdGenerator.ID_PREFIX_CLASSIFICATION);
|
||||
assertThat(classifications)
|
||||
.allMatch(c -> c.getId() != null)
|
||||
.usingRecursiveFieldByFieldElementComparatorIgnoringFields("id")
|
||||
.containsExactlyInAnyOrder(
|
||||
classification.asSummary(), expectedMasterClassification.asSummary());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@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");
|
||||
classification.setServiceLevel("P1D");
|
||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
Instant before = Instant.now();
|
||||
// Sometimes the test execution is too fast. Therefore, we have to slow it down.
|
||||
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_SERVICE.newClassification("someKey234", "DOMAIN_A", "TASK");
|
||||
classification.setServiceLevel("P-1D");
|
||||
classificationService.newClassification("Key2", "DOMAIN_B", "TASK");
|
||||
classificationService.createClassification(classification);
|
||||
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(MalformedServiceLevelException.class);
|
||||
List<ClassificationSummary> classifications =
|
||||
classificationService
|
||||
.createClassificationQuery()
|
||||
.keyIn("Key2")
|
||||
.modifiedWithin(new TimeInterval(before, null))
|
||||
.list();
|
||||
|
||||
assertThat(classifications).containsExactly(classification.asSummary());
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationWithInvalidValues() {
|
||||
CLASSIFICATION_SERVICE.createClassificationQuery().count();
|
||||
@TestFactory
|
||||
Stream<DynamicTest> should_CreateChildClassification() throws Exception {
|
||||
ClassificationSummary parentClassification =
|
||||
DefaultTestEntities.defaultTestClassification()
|
||||
.key("Key3")
|
||||
.domain("DOMAIN_A")
|
||||
.type("TASK")
|
||||
.buildAndStoreAsSummary(classificationService);
|
||||
|
||||
// Check key NULL
|
||||
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 =
|
||||
CLASSIFICATION_SERVICE.newClassification(null, "DOMAIN_A", "TASK");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "TASK");
|
||||
classification.setServiceLevel(invalidServiceLevel);
|
||||
MalformedServiceLevelException expectedException =
|
||||
new MalformedServiceLevelException(invalidServiceLevel, "KeyErrCreation", "DOMAIN_A");
|
||||
|
||||
// Check invalid ServiceLevel
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(MalformedServiceLevelException.class)
|
||||
.usingRecursiveComparison()
|
||||
.isEqualTo(expectedException);
|
||||
};
|
||||
|
||||
Classification classification2 =
|
||||
CLASSIFICATION_SERVICE.newClassification("Key2", "DOMAIN_B", "TASK");
|
||||
classification2.setServiceLevel("abc");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification2))
|
||||
.isInstanceOf(MalformedServiceLevelException.class);
|
||||
return DynamicTest.stream(iterator, c -> String.format("for '%s'", c), test);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationAlreadyExisting() throws Exception {
|
||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key3", "", "TASK");
|
||||
classification.setServiceLevel("P1D");
|
||||
Classification classificationCreated =
|
||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classificationCreated))
|
||||
.isInstanceOf(ClassificationAlreadyExistException.class);
|
||||
void should_ThrowException_When_TryingToCreateClassificationWithInvalidKey() {
|
||||
Classification classificationWithNullKey =
|
||||
classificationService.newClassification(null, "DOMAIN_A", "TASK");
|
||||
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classificationWithNullKey))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("Classification must contain a key");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationInUnknownDomain() {
|
||||
void should_ThrowException_When_TryingToCreateClassificationWithInvalidDomain() {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.newClassification("Key3", "UNKNOWN_DOMAIN", "TASK");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(DomainNotFoundException.class);
|
||||
classificationService.newClassification("KeyErrCreation", "UNKNOWN_DOMAIN", "TASK");
|
||||
DomainNotFoundException expectedException = new DomainNotFoundException("UNKNOWN_DOMAIN");
|
||||
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(DomainNotFoundException.class)
|
||||
.usingRecursiveComparison()
|
||||
.isEqualTo(expectedException);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationOfUnknownType() {
|
||||
void should_ThrowException_TryingToCreateClassificationWithInvalidType() {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.newClassification("Key3", "DOMAIN_A", "UNKNOWN_TYPE");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "UNKNOWN_TYPE");
|
||||
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage(
|
||||
"Given classification type "
|
||||
+ "UNKNOWN_TYPE"
|
||||
+ " is not valid according to the configuration.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationOfUnknownCategory() {
|
||||
void should_ThrowException_TryingToCreateClassificationWithInvalidCategory() {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.newClassification("Key4", "DOMAIN_A", "TASK");
|
||||
classificationService.newClassification("KeyErrCreation", "DOMAIN_A", "TASK");
|
||||
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")
|
||||
@Test
|
||||
void testCreateClassificationWithInvalidParentId() {
|
||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key5", "", "TASK");
|
||||
classification.setParentId("ID WHICH CANT BE FOUND");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
void should_ThrowException_TryingToCreateClassificationWithInvalidParentKey() {
|
||||
Classification classification =
|
||||
classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||
classification.setParentKey("UNKNOWN_KEY");
|
||||
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("Parent classification could not be found.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationWithInvalidParentKey() {
|
||||
Classification classification = CLASSIFICATION_SERVICE.newClassification("Key5", "", "TASK");
|
||||
classification.setParentKey("KEY WHICH CANT BE FOUND");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
void should_ThrowException_TryingToCreateClassificationWithInvalidParentId() {
|
||||
Classification classification = classificationService.newClassification("KeyErr", "", "TASK");
|
||||
classification.setParentId("UNKNOWN_ID");
|
||||
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("Parent classification could not be found.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void testCreateClassificationWithExplicitId() {
|
||||
void should_ThrowException_TryingToCreateClassificationWithExplicitId() {
|
||||
ClassificationImpl classification =
|
||||
(ClassificationImpl) CLASSIFICATION_SERVICE.newClassification("Key0818", "", "TASK");
|
||||
(ClassificationImpl) classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||
classification.setId("EXPLICIT ID");
|
||||
assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void should_BeAbleToCreateNewClassification_When_ClassificationCopy() throws Exception {
|
||||
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());
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("ClassificationId should be null on creation");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "taskadmin")
|
||||
@WithAccessId(user = "user-1-1")
|
||||
@TestTemplate
|
||||
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
|
||||
ClassificationImpl classification =
|
||||
(ClassificationImpl) CLASSIFICATION_SERVICE.newClassification("newKey718", "", "TASK");
|
||||
void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin(WithAccessId accessId) {
|
||||
Classification classification =
|
||||
classificationService.newClassification("KeyErrCreation", "", "TASK");
|
||||
MismatchedRoleException expectedException =
|
||||
new MismatchedRoleException(accessId.user(), TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
|
||||
|
||||
ThrowingCallable createClassificationCall =
|
||||
() -> {
|
||||
CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
};
|
||||
|
||||
assertThatThrownBy(createClassificationCall).isInstanceOf(NotAuthorizedException.class);
|
||||
assertThatThrownBy(() -> classificationService.createClassification(classification))
|
||||
.isInstanceOf(MismatchedRoleException.class)
|
||||
.usingRecursiveComparison()
|
||||
.isEqualTo(expectedException);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void should_SetDefaultServiceLevel_When_TryingToCreateClassificationWithMissingServiceLevel()
|
||||
throws Exception {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.newClassification("newKey718", "", "TASK");
|
||||
classification = CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||
void should_ThrowException_WhenClassificationWithKeyAlreadyExisting() throws Exception {
|
||||
String existingKey = "Key4";
|
||||
DefaultTestEntities.defaultTestClassification()
|
||||
.key(existingKey)
|
||||
.buildAndStore(classificationService);
|
||||
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 = CLASSIFICATION_SERVICE.createClassification(classification);
|
||||
|
||||
classification = classificationService.createClassification(classification);
|
||||
|
||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@WithAccessId(user = "businessadmin")
|
||||
@Test
|
||||
void should_SetDefaultServiceLevel_When_TryingToUpdateClassificationWithMissingServiceLevel()
|
||||
throws Exception {
|
||||
Classification classification =
|
||||
CLASSIFICATION_SERVICE.getClassification("CLI:000000000000000000000000000000000001");
|
||||
classification.setServiceLevel(null);
|
||||
classification = CLASSIFICATION_SERVICE.updateClassification(classification);
|
||||
assertThat(classification.getServiceLevel()).isEqualTo("P0D");
|
||||
void should_SetDefaultValues_When_CreatingClassificationWithoutSpecificValues() throws Exception {
|
||||
Classification classification = classificationService.newClassification("Key6", "", "TASK");
|
||||
classification = classificationService.createClassification(classification);
|
||||
|
||||
classification.setServiceLevel("");
|
||||
classification = CLASSIFICATION_SERVICE.updateClassification(classification);
|
||||
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 =
|
||||
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")
|
||||
@Test
|
||||
void testUpdateClassification() throws Exception {
|
||||
|
|
|
|||
Loading…
Reference in New Issue