From 0091fa7027e0b62e546f19c088aedf490b4fa2e5 Mon Sep 17 00:00:00 2001 From: jamesrdi Date: Wed, 17 May 2023 15:18:12 +0200 Subject: [PATCH] Closes #2262 - Refactor GetWorkbasketAccTest to use test-api --- .../workbasket/get/GetWorkbasketAccTest.java | 195 ++++++++++++++++++ .../workbasket/get/GetWorkbasketAccTest.java | 186 ----------------- 2 files changed, 195 insertions(+), 186 deletions(-) create mode 100644 lib/taskana-core-test/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java delete mode 100644 lib/taskana-core/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java diff --git a/lib/taskana-core-test/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java b/lib/taskana-core-test/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java new file mode 100644 index 000000000..8462b98d2 --- /dev/null +++ b/lib/taskana-core-test/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java @@ -0,0 +1,195 @@ +package acceptance.workbasket.get; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.catchThrowableOfType; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestClassification; +import static pro.taskana.testapi.DefaultTestEntities.defaultTestObjectReference; +import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_1; +import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_2; +import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_3; +import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_4; + +import java.util.List; +import java.util.stream.Stream; +import org.assertj.core.api.ThrowableAssert.ThrowingCallable; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DynamicTest; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestFactory; +import org.junit.jupiter.api.TestTemplate; +import org.junit.jupiter.api.function.ThrowingConsumer; +import pro.taskana.classification.api.ClassificationService; +import pro.taskana.classification.api.models.ClassificationSummary; +import pro.taskana.common.internal.util.Triplet; +import pro.taskana.task.api.models.ObjectReference; +import pro.taskana.testapi.TaskanaInject; +import pro.taskana.testapi.TaskanaIntegrationTest; +import pro.taskana.testapi.builder.WorkbasketAccessItemBuilder; +import pro.taskana.testapi.builder.WorkbasketBuilder; +import pro.taskana.testapi.security.WithAccessId; +import pro.taskana.workbasket.api.WorkbasketPermission; +import pro.taskana.workbasket.api.WorkbasketService; +import pro.taskana.workbasket.api.WorkbasketType; +import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException; +import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException; +import pro.taskana.workbasket.api.models.Workbasket; +import pro.taskana.workbasket.api.models.WorkbasketSummary; + +@TaskanaIntegrationTest +public class GetWorkbasketAccTest { + @TaskanaInject ClassificationService classificationService; + @TaskanaInject WorkbasketService workbasketService; + ClassificationSummary defaultClassificationSummary; + WorkbasketSummary defaultWorkbasketSummary; + ObjectReference defaultObjectReference; + + @WithAccessId(user = "businessadmin") + @BeforeAll + void setup() throws Exception { + defaultClassificationSummary = + defaultTestClassification().buildAndStoreAsSummary(classificationService); + defaultWorkbasketSummary = + WorkbasketBuilder.newWorkbasket() + .domain("DOMAIN_A") + .description("PPK User 2 KSC 1") + .name("PPK User 2 KSC 1") + .key("USER-1-2") + .type(WorkbasketType.PERSONAL) + .owner("user-1-2") + .orgLevel1("versicherung") + .orgLevel2("abteilung") + .orgLevel3("projekt") + .orgLevel4("team") + .customAttribute(CUSTOM_1, "custom1") + .customAttribute(CUSTOM_2, "custom2") + .customAttribute(CUSTOM_3, "custom3") + .customAttribute(CUSTOM_4, "custom4") + .buildAndStoreAsSummary(workbasketService); + + WorkbasketAccessItemBuilder.newWorkbasketAccessItem() + .workbasketId(defaultWorkbasketSummary.getId()) + .accessId("user-1-2") + .permission(WorkbasketPermission.OPEN) + .permission(WorkbasketPermission.READ) + .permission(WorkbasketPermission.TRANSFER) + .permission(WorkbasketPermission.APPEND) + .buildAndStore(workbasketService); + + defaultObjectReference = defaultTestObjectReference().build(); + } + + @WithAccessId(user = "user-1-2") + @Test + void should_ReturnWorkbasketWithId_When_IdIsValidAndUserHasPermissions() throws Exception { + Workbasket workbasket = workbasketService.getWorkbasket(defaultWorkbasketSummary.getId()); + + assertThat(workbasket.asSummary()).isEqualTo(defaultWorkbasketSummary); + } + + @WithAccessId(user = "admin") + @WithAccessId(user = "businessadmin") + @WithAccessId(user = "taskadmin") + @TestTemplate + void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInAdministrativeRole() + throws Exception { + Workbasket workbasket = workbasketService.getWorkbasket(defaultWorkbasketSummary.getId()); + + assertThat(workbasket.asSummary()).isEqualTo(defaultWorkbasketSummary); + } + + @WithAccessId(user = "user-1-1", groups = "user-1-2") + @Test + void should_ReturnWorkbasketPermissions_When_IdIsValidAndUserHasPermissions() { + List permissions = + workbasketService.getPermissionsForWorkbasket(defaultWorkbasketSummary.getId()); + + assertThat(permissions).hasSize(4); + assertThat(permissions.contains(WorkbasketPermission.READ)).isTrue(); + assertThat(permissions.contains(WorkbasketPermission.OPEN)).isTrue(); + assertThat(permissions.contains(WorkbasketPermission.TRANSFER)).isTrue(); + assertThat(permissions.contains(WorkbasketPermission.APPEND)).isTrue(); + } + + @WithAccessId(user = "user-1-1") + @Test + void should_ReturnNoWorkbasketPermissions_When_ProvidingAnInvalidId() { + List permissions = + workbasketService.getPermissionsForWorkbasket("WBI:invalid"); + + assertThat(permissions).isEmpty(); + } + + @WithAccessId(user = "user-1-2") + @Test + void should_ReturnWorkbasketSummary_When_IdIsValidAndSummaryIsRequested() throws Exception { + WorkbasketSummary workbasketSummary = + workbasketService.getWorkbasket(defaultWorkbasketSummary.getId()).asSummary(); + + assertThat(workbasketSummary).isEqualTo(defaultWorkbasketSummary); + } + + @Test + void should_ThrowException_When_ProvidingAnInvalidId() { + ThrowingCallable call = () -> workbasketService.getWorkbasket("INVALID_ID"); + + WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class); + + assertThat(e.getId()).isEqualTo("INVALID_ID"); + } + + @TestFactory + Stream should_ThrowException_When_KeyOrDomainIsInvalid() { + List> list = + List.of( + Triplet.of("With Invalid Domain", "USER-1-2", "INVALID_DOMAIN"), + Triplet.of("With Invalid Key", "INVALID_ID", "DOMAIN_A"), + Triplet.of("With Invalid Key and Domain", "INAVLID_ID", "INVALID_DOMAIN")); + ThrowingConsumer> testGetWorkbasket = + t -> { + ThrowingCallable call = + () -> workbasketService.getWorkbasket(t.getMiddle(), t.getRight()); + + WorkbasketNotFoundException e = + catchThrowableOfType(call, WorkbasketNotFoundException.class); + + assertThat(e.getKey()).isEqualTo(t.getMiddle()); + assertThat(e.getDomain()).isEqualTo(t.getRight()); + }; + return DynamicTest.stream(list.iterator(), Triplet::getLeft, testGetWorkbasket); + } + + @Test + void should_ThrowException_When_TryingToGetByIdWithoutPermissions() { + ThrowingCallable call = () -> workbasketService.getWorkbasket(defaultWorkbasketSummary.getId()); + + NotAuthorizedOnWorkbasketException e = + catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class); + + assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId()); + assertThat(e.getCurrentUserId()).isEqualTo(null); + assertThat(e.getRequiredPermissions()).containsExactly(WorkbasketPermission.READ); + } + + @Test + void should_ThrowException_When_TryingToGetByKeyAndDomainWithoutPermissions() { + ThrowingCallable call = () -> workbasketService.getWorkbasket("USER-1-2", "DOMAIN_A"); + + NotAuthorizedOnWorkbasketException e = + catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class); + + assertThat(e.getWorkbasketKey()).isEqualTo("USER-1-2"); + assertThat(e.getDomain()).isEqualTo("DOMAIN_A"); + assertThat(e.getCurrentUserId()).isEqualTo(null); + assertThat(e.getRequiredPermissions()).containsExactly(WorkbasketPermission.READ); + } + + @WithAccessId(user = "user-1-1") + @Test + void should_ThrowException_When_TryingToGetWithAnInvalidId() { + ThrowingCallable call = () -> workbasketService.getWorkbasket("NOT EXISTING ID"); + + WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class); + + assertThat(e.getId()).isEqualTo("NOT EXISTING ID"); + } +} diff --git a/lib/taskana-core/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java b/lib/taskana-core/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java deleted file mode 100644 index 781adbf69..000000000 --- a/lib/taskana-core/src/test/java/acceptance/workbasket/get/GetWorkbasketAccTest.java +++ /dev/null @@ -1,186 +0,0 @@ -package acceptance.workbasket.get; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_1; -import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_2; -import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_3; -import static pro.taskana.workbasket.api.WorkbasketCustomField.CUSTOM_4; - -import acceptance.AbstractAccTest; -import java.util.List; -import org.assertj.core.api.ThrowableAssert.ThrowingCallable; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.TestTemplate; -import org.junit.jupiter.api.extension.ExtendWith; -import pro.taskana.common.test.security.JaasExtension; -import pro.taskana.common.test.security.WithAccessId; -import pro.taskana.workbasket.api.WorkbasketPermission; -import pro.taskana.workbasket.api.WorkbasketService; -import pro.taskana.workbasket.api.WorkbasketType; -import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException; -import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException; -import pro.taskana.workbasket.api.models.Workbasket; -import pro.taskana.workbasket.api.models.WorkbasketSummary; - -/** Acceptance test for all "get workbasket" scenarios. */ -@ExtendWith(JaasExtension.class) -class GetWorkbasketAccTest extends AbstractAccTest { - - private static final WorkbasketService WORKBASKET_SERVICE = taskanaEngine.getWorkbasketService(); - - @WithAccessId(user = "user-1-2") - @Test - void should_ReturnWorkbasketWithId_When_IdIsValidAndUserHasPermissions() throws Exception { - - Workbasket workbasket = - WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000007"); - - assertThat(workbasket.getDomain()).isEqualTo("DOMAIN_A"); - assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasket.getName()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasket.getKey()).isEqualTo("USER-1-2"); - assertThat(workbasket.getType()).isEqualTo(WorkbasketType.PERSONAL); - assertThat(workbasket.getOwner()).isEqualTo("user-1-2"); - assertThat(workbasket.getOrgLevel1()).isEqualTo("versicherung"); - assertThat(workbasket.getOrgLevel2()).isEqualTo("abteilung"); - assertThat(workbasket.getOrgLevel3()).isEqualTo("projekt"); - assertThat(workbasket.getOrgLevel4()).isEqualTo("team"); - assertThat(workbasket.getCustomField(CUSTOM_1)).isEqualTo("custom1"); - assertThat(workbasket.getCustomField(CUSTOM_2)).isEqualTo("custom2"); - assertThat(workbasket.getCustomField(CUSTOM_3)).isEqualTo("custom3"); - assertThat(workbasket.getCustomField(CUSTOM_4)).isEqualTo("custom4"); - } - - @WithAccessId(user = "admin") - @WithAccessId(user = "businessadmin") - @WithAccessId(user = "taskadmin") - @TestTemplate - void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionButUserHasAdministrativeRole() - throws Exception { - - Workbasket retrievedWorkbasket = - WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000007"); - - assertThat(retrievedWorkbasket).isNotNull(); - assertThat(retrievedWorkbasket.getOwner()).isEqualTo("user-1-2"); - } - - @WithAccessId(user = "admin") - @WithAccessId(user = "businessadmin") - @WithAccessId(user = "taskadmin") - @TestTemplate - void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInAdministrativeRole() - throws Exception { - - Workbasket retrievedWorkbasket = WORKBASKET_SERVICE.getWorkbasket("USER-1-2", "DOMAIN_A"); - assertThat(retrievedWorkbasket.getOwner()).isEqualTo("user-1-2"); - - assertThat(retrievedWorkbasket).isNotNull(); - } - - @WithAccessId(user = "user-1-2") - @Test - void should_ReturnWorkbasketWithKeyAndDomainAndIgnoreCapitalization_When_KeyAndDomainAreValid() - throws Exception { - - Workbasket workbasket = WORKBASKET_SERVICE.getWorkbasket("user-1-2", "domain_a"); - - assertThat(workbasket.getId()).isEqualTo("WBI:100000000000000000000000000000000007"); - assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasket.getName()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasket.getType()).isEqualTo(WorkbasketType.PERSONAL); - assertThat(workbasket.getOwner()).isEqualTo("user-1-2"); - assertThat(workbasket.getOrgLevel1()).isEqualTo("versicherung"); - assertThat(workbasket.getOrgLevel2()).isEqualTo("abteilung"); - assertThat(workbasket.getOrgLevel3()).isEqualTo("projekt"); - assertThat(workbasket.getOrgLevel4()).isEqualTo("team"); - assertThat(workbasket.getCustomField(CUSTOM_1)).isEqualTo("custom1"); - assertThat(workbasket.getCustomField(CUSTOM_2)).isEqualTo("custom2"); - assertThat(workbasket.getCustomField(CUSTOM_3)).isEqualTo("custom3"); - assertThat(workbasket.getCustomField(CUSTOM_4)).isEqualTo("custom4"); - } - - @WithAccessId(user = "user-1-1", groups = GROUP_1_DN) - @Test - void should_ReturnWorkbasketPermissions_When_IdIsValidAndUserHasPermissions() { - List permissions = - WORKBASKET_SERVICE.getPermissionsForWorkbasket("WBI:100000000000000000000000000000000007"); - - assertThat(permissions).hasSize(4); - assertThat(permissions.contains(WorkbasketPermission.READ)).isTrue(); - assertThat(permissions.contains(WorkbasketPermission.OPEN)).isTrue(); - assertThat(permissions.contains(WorkbasketPermission.TRANSFER)).isTrue(); - assertThat(permissions.contains(WorkbasketPermission.APPEND)).isTrue(); - } - - @WithAccessId(user = "user-1-1") - @Test - void should_ReturnNoWorkbasketPermissions_When_ProvidingAnInvalidId() { - List permissions = - WORKBASKET_SERVICE.getPermissionsForWorkbasket("WBI:invalid"); - - assertThat(permissions).isEmpty(); - } - - @WithAccessId(user = "user-1-2") - @Test - void should_ReturnWorkbasketSummary_When_IdIsValidAndSummaryIsRequested() throws Exception { - - WorkbasketSummary workbasketSummary = - WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000007").asSummary(); - - assertThat(workbasketSummary.getDomain()).isEqualTo("DOMAIN_A"); - assertThat(workbasketSummary.getDescription()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasketSummary.getName()).isEqualTo("PPK User 2 KSC 1"); - assertThat(workbasketSummary.getKey()).isEqualTo("USER-1-2"); - assertThat(workbasketSummary.getType()).isEqualTo(WorkbasketType.PERSONAL); - assertThat(workbasketSummary.getOwner()).isEqualTo("user-1-2"); - assertThat(workbasketSummary.getOrgLevel1()).isEqualTo("versicherung"); - assertThat(workbasketSummary.getOrgLevel2()).isEqualTo("abteilung"); - assertThat(workbasketSummary.getOrgLevel3()).isEqualTo("projekt"); - assertThat(workbasketSummary.getOrgLevel4()).isEqualTo("team"); - assertThat(workbasketSummary.getCustomField(CUSTOM_1)).isEqualTo("custom1"); - assertThat(workbasketSummary.getCustomField(CUSTOM_2)).isEqualTo("custom2"); - assertThat(workbasketSummary.getCustomField(CUSTOM_3)).isEqualTo("custom3"); - assertThat(workbasketSummary.getCustomField(CUSTOM_4)).isEqualTo("custom4"); - assertThat(workbasketSummary.isMarkedForDeletion()).isFalse(); - } - - @Test - void should_ThrowException_When_ProvidingAnInvalidId() { - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("INVALID_ID")) - .isInstanceOf(WorkbasketNotFoundException.class); - } - - @Test - void testThrowsExceptionIfKeyOrDomainIsInvalid() { - - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("USER-1-2", "INVALID_DOMAIN")) - .isInstanceOf(WorkbasketNotFoundException.class); - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("INVALID_ID", "DOMAIN_A")) - .isInstanceOf(WorkbasketNotFoundException.class); - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("INAVLID_ID", "INVALID_DOMAIN")) - .isInstanceOf(WorkbasketNotFoundException.class); - } - - @Test - void should_ThrowException_When_TryingToGetByIdWithoutPermissions() { - ThrowingCallable call = - () -> WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000001"); - assertThatThrownBy(call).isInstanceOf(NotAuthorizedOnWorkbasketException.class); - } - - @Test - void should_ThrowException_When_TryingToGetByKeyAndDomainWithoutPermissions() { - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("GPK_KSC", "DOMAIN_A")) - .isInstanceOf(NotAuthorizedOnWorkbasketException.class); - } - - @WithAccessId(user = "user-1-1") - @Test - void should_ThrowException_When_TryingToGetWithAnInvalidId() { - assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("NOT EXISTING ID")) - .isInstanceOf(WorkbasketNotFoundException.class); - } -}