From 3278137977ee6f5b1a99a918877c0cff5a55967b Mon Sep 17 00:00:00 2001 From: Yakup Ensar Evli <54323073+ensarevlideveloper@users.noreply.github.com> Date: Tue, 15 Feb 2022 16:43:44 +0100 Subject: [PATCH] TSK-1794: Updated CreateClassificationAccTest to use Test-API Cleaned up Test cases and improved quality. Transfered one test method from CreateClassificationServiceAccTest to UpdateClassificationAccTest. --- .../CreateClassificationAccTest.java | 428 +++++++++--------- .../UpdateClassificationAccTest.java | 16 + 2 files changed, 239 insertions(+), 205 deletions(-) diff --git a/lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java index cfedca2fa..8afd97324 100644 --- a/lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java @@ -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 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 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 classifications = + classificationService + .createClassificationQuery() + .keyIn("Key2") + .modifiedWithin(new TimeInterval(before, null)) + .list(); + + assertThat(classifications).containsExactly(classification.asSummary()); + } + + @WithAccessId(user = "businessadmin") + @TestFactory + Stream should_CreateChildClassification() throws Exception { + ClassificationSummary parentClassification = + DefaultTestEntities.defaultTestClassification() + .key("Key3") + .domain("DOMAIN_A") + .type("TASK") + .buildAndStoreAsSummary(classificationService); + + List>> 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>> test = + pair -> { + Classification childClassification = + classificationService.newClassification("Key3_" + i.get(), "DOMAIN_A", "TASK"); + pair.getRight().accept(childClassification); + + classificationService.createClassification(childClassification); + + List 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 + should_ThrowException_When_TryingToCreateClassificationWithInvalidServiceLevel() { + Iterator iterator = Arrays.asList("P-1D", "abc").iterator(); + ThrowingConsumer 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") @Test - void testCreateClassificationWithInvalidValues() { - CLASSIFICATION_SERVICE.createClassificationQuery().count(); + void should_ThrowException_When_TryingToCreateClassificationWithInvalidKey() { + 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_SERVICE.newClassification(null, "DOMAIN_A", "TASK"); - assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification)) - .isInstanceOf(InvalidArgumentException.class); + classificationService.newClassification("KeyErrCreation", "UNKNOWN_DOMAIN", "TASK"); + DomainNotFoundException expectedException = new DomainNotFoundException("UNKNOWN_DOMAIN"); - // Check invalid ServiceLevel - - Classification classification2 = - CLASSIFICATION_SERVICE.newClassification("Key2", "DOMAIN_B", "TASK"); - classification2.setServiceLevel("abc"); - assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification2)) - .isInstanceOf(MalformedServiceLevelException.class); + assertThatThrownBy(() -> classificationService.createClassification(classification)) + .isInstanceOf(DomainNotFoundException.class) + .usingRecursiveComparison() + .isEqualTo(expectedException); } @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); - } - - @WithAccessId(user = "businessadmin") - @Test - void testCreateClassificationInUnknownDomain() { + void should_ThrowException_TryingToCreateClassificationWithInvalidType() { Classification classification = - CLASSIFICATION_SERVICE.newClassification("Key3", "UNKNOWN_DOMAIN", "TASK"); - assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification)) - .isInstanceOf(DomainNotFoundException.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 testCreateClassificationOfUnknownType() { + void should_ThrowException_TryingToCreateClassificationWithInvalidCategory() { Classification classification = - CLASSIFICATION_SERVICE.newClassification("Key3", "DOMAIN_A", "UNKNOWN_TYPE"); - assertThatThrownBy(() -> CLASSIFICATION_SERVICE.createClassification(classification)) - .isInstanceOf(InvalidArgumentException.class); - } - - @WithAccessId(user = "businessadmin") - @Test - void testCreateClassificationOfUnknownCategory() { - 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(); } } diff --git a/lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java b/lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java index 4bbfbdb93..f23e730d5 100644 --- a/lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java +++ b/lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java @@ -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 {