Skip to content

Commit

Permalink
Closes Taskana#2262 - Refactor GetWorkbasketAccTest to use test-api
Browse files Browse the repository at this point in the history
  • Loading branch information
@jamesrdi
jamesrdi committed May 19, 2023
1 parent 1158ea0 commit 0156f55
Showing 1 changed file with 114 additions and 54 deletions.
168 changes: 114 additions & 54 deletions .../workbasket/get/GetWorkbasketAccTest.java → .../workbasket/get/GetWorkbasketAccTest.java
View file
@@ -1,20 +1,32 @@
package acceptance.workbasket.get;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
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 acceptance.AbstractAccTest;
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.extension.ExtendWith;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
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;
Expand All @@ -23,18 +35,53 @@
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 {
@TaskanaIntegrationTest
public class GetWorkbasketAccTest {
@TaskanaInject ClassificationService classificationService;
@TaskanaInject WorkbasketService workbasketService;
ClassificationSummary defaultClassificationSummary;
WorkbasketSummary defaultWorkbasketSummary;
ObjectReference defaultObjectReference;

private static final WorkbasketService WORKBASKET_SERVICE = taskanaEngine.getWorkbasketService();
@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 =
WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000007");
Workbasket workbasket = workbasketService.getWorkbasket(defaultWorkbasketSummary.getId());

assertThat(workbasket.getDomain()).isEqualTo("DOMAIN_A");
assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1");
Expand All @@ -58,12 +105,10 @@ void should_ReturnWorkbasketWithId_When_IdIsValidAndUserHasPermissions() throws
@TestTemplate
void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionButUserHasAdministrativeRole()
throws Exception {
Workbasket workbasket = workbasketService.getWorkbasket(defaultWorkbasketSummary.getId());

Workbasket retrievedWorkbasket =
WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000007");

assertThat(retrievedWorkbasket).isNotNull();
assertThat(retrievedWorkbasket.getOwner()).isEqualTo("user-1-2");
assertThat(workbasket).isNotNull();
assertThat(workbasket.getOwner()).isEqualTo("user-1-2");
}

@WithAccessId(user = "admin")
Expand All @@ -72,21 +117,9 @@ void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionButUserHasAd
@TestTemplate
void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
throws Exception {
Workbasket workbasket = workbasketService.getWorkbasket("user-1-2", "domain_a");

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.getId()).isEqualTo(defaultWorkbasketSummary.getId());
assertThat(workbasket.getDescription()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getName()).isEqualTo("PPK User 2 KSC 1");
assertThat(workbasket.getType()).isEqualTo(WorkbasketType.PERSONAL);
Expand All @@ -101,11 +134,11 @@ void should_ReturnWorkbasketWithKeyAndDomainAndIgnoreCapitalization_When_KeyAndD
assertThat(workbasket.getCustomField(CUSTOM_4)).isEqualTo("custom4");
}

@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
@WithAccessId(user = "user-1-1", groups = "user-1-2")
@Test
void should_ReturnWorkbasketPermissions_When_IdIsValidAndUserHasPermissions() {
List<WorkbasketPermission> permissions =
WORKBASKET_SERVICE.getPermissionsForWorkbasket("WBI:100000000000000000000000000000000007");
workbasketService.getPermissionsForWorkbasket(defaultWorkbasketSummary.getId());

assertThat(permissions).hasSize(4);
assertThat(permissions.contains(WorkbasketPermission.READ)).isTrue();
Expand All @@ -118,17 +151,16 @@ void should_ReturnWorkbasketPermissions_When_IdIsValidAndUserHasPermissions() {
@Test
void should_ReturnNoWorkbasketPermissions_When_ProvidingAnInvalidId() {
List<WorkbasketPermission> permissions =
WORKBASKET_SERVICE.getPermissionsForWorkbasket("WBI:invalid");
workbasketService.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();
workbasketService.getWorkbasket(defaultWorkbasketSummary.getId()).asSummary();

assertThat(workbasketSummary.getDomain()).isEqualTo("DOMAIN_A");
assertThat(workbasketSummary.getDescription()).isEqualTo("PPK User 2 KSC 1");
Expand All @@ -149,38 +181,66 @@ void should_ReturnWorkbasketSummary_When_IdIsValidAndSummaryIsRequested() throws

@Test
void should_ThrowException_When_ProvidingAnInvalidId() {
assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("INVALID_ID"))
.isInstanceOf(WorkbasketNotFoundException.class);
ThrowingCallable call = () -> workbasketService.getWorkbasket("INVALID_ID");

WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class);

assertThat(e.getId()).isEqualTo("INVALID_ID");
}

@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);
@TestFactory
Stream<DynamicTest> should_ThrowException_When_KeyOrDomainIsInvalid() {
List<Triplet<String, String, String>> 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<Triplet<String, String, String>> 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 =
() -> WORKBASKET_SERVICE.getWorkbasket("WBI:100000000000000000000000000000000001");
assertThatThrownBy(call).isInstanceOf(NotAuthorizedOnWorkbasketException.class);
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() {
assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("GPK_KSC", "DOMAIN_A"))
.isInstanceOf(NotAuthorizedOnWorkbasketException.class);
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() {
assertThatThrownBy(() -> WORKBASKET_SERVICE.getWorkbasket("NOT EXISTING ID"))
.isInstanceOf(WorkbasketNotFoundException.class);
ThrowingCallable call = () -> workbasketService.getWorkbasket("NOT EXISTING ID");

WorkbasketNotFoundException e = catchThrowableOfType(call, WorkbasketNotFoundException.class);

assertThat(e.getId()).isEqualTo("NOT EXISTING ID");
}
}

0 comments on commit 0156f55

Please sign in to comment.