Usage of the new TestTemplate-feature

-for running tests multiple times with different AccessIds

lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java

@@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import acceptance.AbstractAccTest;
 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.classification.api.ClassificationService;
@@ -269,8 +270,9 @@ class CreateClassificationAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "taskadmin")
-  @Test
+  @WithAccessId(user = "user_1_1")
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToCreateClassification() {
+  @TestTemplate
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
     ClassificationImpl classification =
         (ClassificationImpl) classificationService.newClassification("newKey718", "", "TASK");
 

lib/taskana-core/src/test/java/acceptance/classification/DeleteClassificationAccTest.java

@@ -6,6 +6,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import acceptance.AbstractAccTest;
 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.classification.api.ClassificationService;
@@ -16,7 +17,9 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
 import pro.taskana.common.internal.security.JaasExtension;
 import pro.taskana.common.internal.security.WithAccessId;
 
-/** Acceptance test for all "delete classification" scenarios. */
+/**
+ * Acceptance test for all "delete classification" scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 class DeleteClassificationAccTest extends AbstractAccTest {
 
@@ -48,17 +51,16 @@ class DeleteClassificationAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "taskadmin")
-  @Test
+  @WithAccessId(user = "user_1_1")
-  void
+  @TestTemplate
-      should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToDelClassificationByKeyDomain() {
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
-    ThrowingCallable call = () -> classificationService.deleteClassification("L140101", "DOMAIN_A");
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
 
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToDeleteClassificationById() {
     ThrowingCallable call =
+        () -> classificationService.deleteClassification("L140101", "DOMAIN_A");
+
+    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
+
+    call =
         () ->
             classificationService.deleteClassification("CLI:000000000000000000000000000000000009");
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);

lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java

@@ -11,6 +11,7 @@ import java.util.Arrays;
 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.classification.api.ClassificationService;
@@ -111,8 +112,9 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "taskadmin")
-  @Test
+  @WithAccessId(user = "user_1_1")
-  public void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToUpdateClassification()
+  @TestTemplate
+  public void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin()
       throws ClassificationNotFoundException {
 
     Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");

lib/taskana-core/src/test/java/acceptance/task/CancelTaskAccTest.java

@@ -4,10 +4,12 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import acceptance.AbstractAccTest;
+import java.sql.SQLException;
 import java.util.List;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
@@ -20,9 +22,12 @@ import pro.taskana.task.api.exceptions.TaskNotFoundException;
 import pro.taskana.task.api.models.Task;
 import pro.taskana.task.api.models.TaskSummary;
 
-/** Acceptance tests for all "cancel task" scenarios. */
+/**
+ * Acceptance tests for all "cancel task" scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 class CancelTaskAccTest extends AbstractAccTest {
+
   private TaskService taskService;
 
   CancelTaskAccTest() {
@@ -56,11 +61,13 @@ class CancelTaskAccTest extends AbstractAccTest {
     assertThat(numTasks).isEqualTo(6);
   }
 
+  @WithAccessId(user = "admin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_CancelTask_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_CancelTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
-      throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
+      throws NotAuthorizedException, TaskNotFoundException, InvalidStateException, SQLException {
 
+    resetDb(false);
     Task tasktoCancel = taskService.getTask("TKI:000000000000000000000000000000000001");
     assertThat(tasktoCancel.getState()).isEqualTo(TaskState.CLAIMED);
 

lib/taskana-core/src/test/java/acceptance/task/CompleteTaskAccTest.java

@@ -4,9 +4,11 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import acceptance.AbstractAccTest;
+import java.sql.SQLException;
 import java.time.Instant;
 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.classification.api.exceptions.ClassificationNotFoundException;
@@ -25,7 +27,9 @@ import pro.taskana.task.api.models.Task;
 import pro.taskana.task.internal.models.TaskImpl;
 import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
 
-/** Acceptance tests for all claim and complete scenarios. */
+/**
+ * Acceptance tests for all claim and complete scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 class CompleteTaskAccTest extends AbstractAccTest {
 
@@ -49,11 +53,14 @@ class CompleteTaskAccTest extends AbstractAccTest {
     assertThat(completedTask.getModified()).isNotEqualTo(completedTask.getCreated());
   }
 
+  @WithAccessId(user = "admin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_ForceCompleteTask_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_ForceCompleteTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws TaskNotFoundException, InvalidStateException, InvalidOwnerException,
-          NotAuthorizedException {
+                 NotAuthorizedException, SQLException {
+
+    resetDb(false);
     TaskService taskService = taskanaEngine.getTaskService();
 
     assertThat(taskService.getTask("TKI:000000000000000000000000000000000000").getState())

lib/taskana-core/src/test/java/acceptance/task/CreateTaskAccTest.java

@@ -17,6 +17,7 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.assertj.core.data.TemporalUnitWithinOffset;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.classification.api.ClassificationService;
@@ -47,7 +48,9 @@ import pro.taskana.workbasket.api.models.Workbasket;
 
 // import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 
-/** Acceptance test for all "create task" scenarios. */
+/**
+ * Acceptance test for all "create task" scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 class CreateTaskAccTest extends AbstractAccTest {
 
@@ -109,18 +112,21 @@ class CreateTaskAccTest extends AbstractAccTest {
     assertThat(createdTask.isTransferred()).isFalse();
   }
 
+  @WithAccessId(user = "admin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_CreateTask_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_CreateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws TaskAlreadyExistException, InvalidArgumentException, WorkbasketNotFoundException,
                  NotAuthorizedException, ClassificationNotFoundException {
 
+    String currentUser = CurrentUserContext.getUserid();
+
     Task newTask = taskService.newTask("USER_1_1", "DOMAIN_A");
     newTask.setClassificationKey("T2100");
     ObjectReference objectReference =
         createObjectReference("COMPANY_A", "SYSTEM_A", "INSTANCE_A", "VNR", "1234567");
     newTask.setPrimaryObjRef(objectReference);
-    newTask.setOwner("taskadmin");
+    newTask.setOwner(currentUser);
     Task createdTask = taskService.createTask(newTask);
 
     assertThat(createdTask).isNotNull();

lib/taskana-core/src/test/java/acceptance/task/DeleteTaskAccTest.java

@@ -8,6 +8,7 @@ import java.util.ArrayList;
 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.api.BulkOperationResults;
@@ -60,9 +61,11 @@ class DeleteTaskAccTest extends AbstractAccTest {
     assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
   }
 
+  @WithAccessId(user = "businessadmin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @WithAccessId(user = "user_1_1")
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToDeleteTask() {
+  @TestTemplate
+  void should_ThrowException_When_UserIsNotInAdminRole() {
 
     TaskService taskService = taskanaEngine.getTaskService();
 

lib/taskana-core/src/test/java/acceptance/task/DeleteTaskCommentAccTest.java

@@ -4,9 +4,11 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import acceptance.AbstractAccTest;
+import java.sql.SQLException;
 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.api.exceptions.InvalidArgumentException;
@@ -67,11 +69,14 @@ public class DeleteTaskCommentAccTest extends AbstractAccTest {
     assertThat(taskCommentsAfterDeletion).hasSize(3);
   }
 
+  @WithAccessId(user = "admin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_DeleteTaskComment_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_DeleteTaskComment_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws NotAuthorizedException, TaskNotFoundException, TaskCommentNotFoundException,
-          InvalidArgumentException {
+                 InvalidArgumentException, SQLException {
+
+    resetDb(false);
 
     TaskService taskService = taskanaEngine.getTaskService();
 

lib/taskana-core/src/test/java/acceptance/task/GetTaskAccTest.java

@@ -7,6 +7,7 @@ import acceptance.AbstractAccTest;
 import java.util.HashMap;
 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.api.exceptions.InvalidArgumentException;
@@ -18,7 +19,9 @@ import pro.taskana.task.api.TaskState;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
 import pro.taskana.task.api.models.Task;
 
-/** Acceptance test for all "get task" scenarios. */
+/**
+ * Acceptance test for all "get task" scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 class GetTaskAccTest extends AbstractAccTest {
 
@@ -107,9 +110,10 @@ class GetTaskAccTest extends AbstractAccTest {
     assertThatThrownBy(getTaskCall).isInstanceOf(NotAuthorizedException.class);
   }
 
+  @WithAccessId(user = "admin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_ReturnTask_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_ReturnTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws NotAuthorizedException, TaskNotFoundException {
 
     TaskService taskService = taskanaEngine.getTaskService();

lib/taskana-core/src/test/java/acceptance/task/TerminateTaskAccTest.java

@@ -9,6 +9,7 @@ import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.common.api.exceptions.NotAuthorizedException;
@@ -44,7 +45,8 @@ class TerminateTaskAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "admin", groups = "group_1")
-  @Test
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
   void should_TerminateTask_When_TaskStateIsReady()
       throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
     List<TaskSummary> taskSummaries = taskService.createTaskQuery().stateIn(TaskState.READY).list();
@@ -56,8 +58,9 @@ class TerminateTaskAccTest extends AbstractAccTest {
     assertThat(numTasks).isEqualTo(6);
   }
 
-  @WithAccessId(user = "taskadmin", groups = "group_1")
+  @WithAccessId(user = "admin", groups = "group_1")
-  @Test
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
   void should_TerminateTask_When_TaskStateIsClaimed()
       throws NotAuthorizedException, TaskNotFoundException, InvalidStateException {
     List<TaskSummary> taskSummaries =
@@ -87,7 +90,7 @@ class TerminateTaskAccTest extends AbstractAccTest {
 
   @WithAccessId(user = "user_1_2")
   @Test
-  void should_ThrowException_When_UserIsNotAdmin() {
+  void should_ThrowException_When_UserIsNotInAdministrativeRole() {
 
     ThrowingCallable taskanaCall =
         () -> taskService.terminateTask("TKI:000000000000000000000000000000000000");

lib/taskana-core/src/test/java/acceptance/task/TransferTaskAccTest.java

@@ -1,6 +1,7 @@
 package acceptance.task;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 import acceptance.AbstractAccTest;
@@ -11,6 +12,7 @@ import java.util.Collections;
 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.api.BulkOperationResults;
@@ -57,10 +59,10 @@ class TransferTaskAccTest extends AbstractAccTest {
     assertThat(transferredTask.getState()).isEqualTo(TaskState.READY);
   }
 
-  @WithAccessId(
+  @WithAccessId(user = "admin")
-      user = "taskadmin")
+  @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_TransferTask_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_TransferTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws NotAuthorizedException, WorkbasketNotFoundException, TaskNotFoundException,
                  InvalidStateException, InvalidOwnerException {
     TaskService taskService = taskanaEngine.getTaskService();
@@ -302,7 +304,12 @@ class TransferTaskAccTest extends AbstractAccTest {
       throws NotAuthorizedException, InvalidArgumentException, WorkbasketNotFoundException {
     TaskService taskService = taskanaEngine.getTaskService();
     List<String> taskIds = Collections.singletonList("TKI:000000000000000000000000000000000006");
+
+    ThrowingCallable call = () -> {
       taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
+    };
+
+    assertThatCode(call).doesNotThrowAnyException();
   }
 
   @WithAccessId(user = "teamlead_1", groups = "group_1")

lib/taskana-core/src/test/java/acceptance/task/UpdateTaskAccTest.java

@@ -11,6 +11,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
@@ -129,6 +130,31 @@ class UpdateTaskAccTest extends AbstractAccTest {
         .withFailMessage("The task has already been updated by another user");
   }
 
+  @WithAccessId(user = "admin")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  void should_UpdateTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
+      throws TaskNotFoundException, ClassificationNotFoundException, InvalidArgumentException,
+                 ConcurrencyException, NotAuthorizedException, AttachmentPersistenceException,
+                 InvalidStateException, SQLException {
+
+    TaskService taskService = taskanaEngine.getTaskService();
+    Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
+    final ClassificationSummary classificationSummary = task.getClassificationSummary();
+    task.setClassificationKey("T2100");
+    Task updatedTask = taskService.updateTask(task);
+    updatedTask = taskService.getTask(updatedTask.getId());
+
+    assertThat(updatedTask).isNotNull();
+    assertThat(updatedTask.getClassificationSummary().getKey()).isEqualTo("T2100");
+    assertThat(updatedTask.getClassificationSummary()).isNotEqualTo(classificationSummary);
+    assertThat(updatedTask.getCreated()).isNotEqualTo(updatedTask.getModified());
+    assertThat(task.getPlanned()).isEqualTo(updatedTask.getPlanned());
+    assertThat(task.getName()).isEqualTo(updatedTask.getName());
+    assertThat(task.getDescription()).isEqualTo(updatedTask.getDescription());
+    resetDb(false); // classification of task TKI:0..00 was changed...
+  }
+
   @WithAccessId(user = "user_1_1", groups = "group_1")
   @Test
   void should_UpdateTaskProperties_When_ClassificationOfTaskIsChanged()

lib/taskana-core/src/test/java/acceptance/workbasket/CreateWorkbasketAccTest.java

@@ -7,6 +7,7 @@ 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.api.exceptions.DomainNotFoundException;
@@ -62,9 +63,10 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
     assertThat(createdWorkbasket2).isEqualTo(createdWorkbasket);
   }
 
-  @WithAccessId(user = "dummy")
+  @WithAccessId(user = "user_1_1")
-  @Test
+  @WithAccessId(user = "taskadmin")
-  void testCreateWorkbasketNotAuthorized() {
+  @TestTemplate
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
     WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
 
     Workbasket workbasket = workbasketService.newWorkbasket("key3", "DOMAIN_A");
@@ -76,20 +78,6 @@ class CreateWorkbasketAccTest extends AbstractAccTest {
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToCreateWorkbasket() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    Workbasket workbasket = workbasketService.newWorkbasket("NT1234", "DOMAIN_A");
-    workbasket.setName("new workbasket");
-    workbasket.setType(WorkbasketType.GROUP);
-    workbasket.setOrgLevel1("company");
-
-    ThrowingCallable createWorkbasketCall = () -> workbasketService.createWorkbasket(workbasket);
-    assertThatThrownBy(createWorkbasketCall).isInstanceOf(NotAuthorizedException.class);
-  }
-
   @WithAccessId(
       user = "teamlead_1",
       groups = {"group_1", "businessadmin"})

lib/taskana-core/src/test/java/acceptance/workbasket/CreateWorkbasketAuthorizationsAccTest.java

@@ -0,0 +1,39 @@
+package acceptance.workbasket;
+
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import acceptance.AbstractAccTest;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import pro.taskana.common.api.exceptions.NotAuthorizedException;
+import pro.taskana.security.JaasExtension;
+import pro.taskana.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
+
+/**
+ * Acceptance test for all "set workbasket access item" scenarios.
+ */
+@ExtendWith(JaasExtension.class)
+public class CreateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
+
+  @WithAccessId(user = "user_1_1")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    WorkbasketAccessItem accessItem =
+        workbasketService.newWorkbasketAccessItem(
+            "WBI:100000000000000000000000000000000001", "user1");
+    accessItem.setPermAppend(true);
+    accessItem.setPermCustom11(true);
+    accessItem.setPermRead(true);
+    ThrowingCallable call = () -> {
+      workbasketService.createWorkbasketAccessItem(accessItem);
+    };
+    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
+  }
+}

lib/taskana-core/src/test/java/acceptance/workbasket/DeleteWorkbasketAccTest.java

@@ -8,6 +8,7 @@ import java.util.List;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.common.api.exceptions.InvalidArgumentException;
@@ -26,7 +27,9 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
 import pro.taskana.workbasket.api.models.Workbasket;
 import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
 
-/** Acceptance test which does test the deletion of a workbasket and all wanted failures. */
+/**
+ * Acceptance test which does test the deletion of a workbasket and all wanted failures.
+ */
 @ExtendWith(JaasExtension.class)
 class DeleteWorkbasketAccTest extends AbstractAccTest {
 
@@ -56,21 +59,9 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "elena")
-  @Test
-  void testDeleteWorkbasketNotAuthorized() {
-
-    ThrowingCallable call =
-        () -> {
-          Workbasket wb = workbasketService.getWorkbasket("TEAMLEAD_2", "DOMAIN_A");
-          workbasketService.deleteWorkbasket(wb.getId());
-        };
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
-
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
-      should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToDeleteWorkbasketByKeyAndDomain() {
 
     ThrowingCallable deleteWorkbasketCall =
         () -> {
@@ -78,13 +69,8 @@ class DeleteWorkbasketAccTest extends AbstractAccTest {
           workbasketService.deleteWorkbasket(wb.getId());
         };
     assertThatThrownBy(deleteWorkbasketCall).isInstanceOf(NotAuthorizedException.class);
-  }
 
-  @WithAccessId(user = "taskadmin")
+    deleteWorkbasketCall =
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToDeleteWorkbasketById() {
-
-    ThrowingCallable deleteWorkbasketCall =
         () -> {
           Workbasket wb =
               workbasketService.getWorkbasket("WBI:100000000000000000000000000000000005");

lib/taskana-core/src/test/java/acceptance/workbasket/DeleteWorkbasketAuthorizationsAccTest.java

@@ -0,0 +1,51 @@
+package acceptance.workbasket;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import acceptance.AbstractAccTest;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import pro.taskana.common.api.exceptions.NotAuthorizedException;
+import pro.taskana.security.JaasExtension;
+import pro.taskana.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
+
+/**
+ * Acceptance test for all "delete workbasket authorizations" scenarios.
+ */
+@ExtendWith(JaasExtension.class)
+public class DeleteWorkbasketAuthorizationsAccTest extends AbstractAccTest {
+
+  @WithAccessId(user = "user_1_1")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  public void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
+
+    final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    ThrowingCallable deleteWorkbasketAccessItemCall =
+        () -> {
+          workbasketService.deleteWorkbasketAccessItemsForAccessId("group_1");
+        };
+
+    assertThatThrownBy(deleteWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
+
+    WorkbasketAccessItem workbasketAccessItem =
+        workbasketService.newWorkbasketAccessItem(
+            "WBI:100000000000000000000000000000000008", "newAccessIdForUpdate");
+
+    workbasketAccessItem.setPermCustom1(true);
+
+    deleteWorkbasketAccessItemCall =
+        () -> {
+          workbasketService.deleteWorkbasketAccessItem(workbasketAccessItem.getId());
+        };
+
+    assertThatThrownBy(deleteWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
+  }
+
+}
+

lib/taskana-core/src/test/java/acceptance/workbasket/DistributionTargetsAccTest.java

@@ -13,6 +13,7 @@ import java.util.List;
 import java.util.stream.Collectors;
 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.api.exceptions.NotAuthorizedException;
@@ -109,9 +110,10 @@ class DistributionTargetsAccTest extends AbstractAccTest {
     assertThat(beforeCount).isEqualTo(afterCount);
   }
 
-  @WithAccessId(user = "user_3_1", groups = "group_1")
+  @WithAccessId(user = "user_1_1", groups = "group_1")
-  @Test
+  @WithAccessId(user = "taskadmin")
-  void testDistributionTargetCallsFailWithNotAuthorizedException() {
+  @TestTemplate
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdminAndMakesDistTargetCalls() {
     WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
     String existingWb = "WBI:100000000000000000000000000000000001";
 
@@ -308,62 +310,6 @@ class DistributionTargetsAccTest extends AbstractAccTest {
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToGetWorkbasketDistTargets() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable retrieveWorkbasketDistributionTargetsCall =
-        () -> {
-          List<WorkbasketSummary> ws =
-              workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
-        };
-    assertThatThrownBy(retrieveWorkbasketDistributionTargetsCall)
-        .isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToSetWorkbasketDistTargets() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable call =
-        () -> {
-          workbasketService.setDistributionTargets(
-              "WBI:100000000000000000000000000000000004",
-              Arrays.asList("WBI:100000000000000000000000000000000002"));
-        };
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToAddWorkbasketDistTarget() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable call =
-        () -> {
-          workbasketService.addDistributionTarget(
-              "WBI:100000000000000000000000000000000004",
-              "WBI:100000000000000000000000000000000002");
-        };
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToRemoveWorkbasketDistTarget() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable call =
-        () -> {
-          workbasketService.removeDistributionTarget(
-              "WBI:100000000000000000000000000000000004",
-              "WBI:100000000000000000000000000000000002");
-        };
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
-
   @WithAccessId(
       user = "user_2_2",
       groups = {"group_1", "group_2"})

lib/taskana-core/src/test/java/acceptance/workbasket/GetWorkbasketAccTest.java

@@ -7,6 +7,7 @@ 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.api.exceptions.NotAuthorizedException;
@@ -51,9 +52,12 @@ class GetWorkbasketAccTest extends AbstractAccTest {
     assertThat(workbasket.getCustom4()).isEqualTo("custom4");
   }
 
+  @WithAccessId(user = "admin")
+  @WithAccessId(user = "businessadmin")
   @WithAccessId(user = "taskadmin")
-  @Test
+
-  void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  @TestTemplate
+  void should_ReturnWorkbasketByKeyAndDomain_When_NoExplicitPermissionButUserHasAdministrativeRole()
       throws NotAuthorizedException, WorkbasketNotFoundException {
 
     WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
@@ -65,9 +69,11 @@ class GetWorkbasketAccTest extends AbstractAccTest {
     assertThat(retrievedWorkbasket.getOwner()).isEqualTo("Peter Maier");
   }
 
+  @WithAccessId(user = "admin")
+  @WithAccessId(user = "businessadmin")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInTaskAdminRole()
+  void should_ReturnWorkbasketById_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
       throws NotAuthorizedException, WorkbasketNotFoundException {
 
     WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();

lib/taskana-core/src/test/java/acceptance/workbasket/GetWorkbasketAuthorizationsAccTest.java

@@ -0,0 +1,35 @@
+package acceptance.workbasket;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import acceptance.AbstractAccTest;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.TestTemplate;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import pro.taskana.common.api.exceptions.NotAuthorizedException;
+import pro.taskana.security.JaasExtension;
+import pro.taskana.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketService;
+
+/**
+ * Acceptance test for all "get workbasket authorizations" scenarios.
+ */
+@ExtendWith(JaasExtension.class)
+public class GetWorkbasketAuthorizationsAccTest extends AbstractAccTest {
+
+  @WithAccessId(user = "user_1_1")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  public void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin() {
+
+    final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    ThrowingCallable retrieveWorkbasketAccessItemCall =
+        () -> {
+          workbasketService.getWorkbasketAccessItems("WBI:100000000000000000000000000000000008");
+        };
+
+    assertThatThrownBy(retrieveWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
+  }
+}

lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAccTest.java

@@ -8,6 +8,7 @@ import acceptance.AbstractAccTest;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestTemplate;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.common.api.exceptions.ConcurrencyException;
@@ -20,7 +21,9 @@ import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
 import pro.taskana.workbasket.api.models.Workbasket;
 import pro.taskana.workbasket.internal.models.WorkbasketImpl;
 
-/** Acceptance test for all "update workbasket" scenarios. */
+/**
+ * Acceptance test for all "update workbasket" scenarios.
+ */
 @ExtendWith(JaasExtension.class)
 public class UpdateWorkbasketAccTest extends AbstractAccTest {
 
@@ -100,8 +103,9 @@ public class UpdateWorkbasketAccTest extends AbstractAccTest {
   }
 
   @WithAccessId(user = "user_1_1", groups = "group_1")
-  @Test
+  @WithAccessId(user = "taskadmin")
-  public void testCheckAuthorizationToUpdateWorkbasket()
+  @TestTemplate
+  public void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdmin()
       throws NotAuthorizedException, WorkbasketNotFoundException {
     WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
     Workbasket workbasket = workbasketService.getWorkbasket("USER_1_1", "DOMAIN_A");
@@ -111,18 +115,4 @@ public class UpdateWorkbasketAccTest extends AbstractAccTest {
     assertThatThrownBy(() -> workbasketService.updateWorkbasket(workbasket))
         .isInstanceOf(NotAuthorizedException.class);
   }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  public void should_ThrowException_When_UserIsTaskAdminAndNotAuthorizedToUpdateWorkbasket()
-      throws NotAuthorizedException, WorkbasketNotFoundException {
-
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    Workbasket workbasket = workbasketService.getWorkbasket("USER_1_1", "DOMAIN_A");
-
-    workbasket.setName("updated workbasket name");
-
-    assertThatThrownBy(() -> workbasketService.updateWorkbasket(workbasket))
-        .isInstanceOf(NotAuthorizedException.class);
-  }
 }

lib/taskana-core/src/test/java/acceptance/workbasket/UpdateWorkbasketAuthorizationsAccTest.java

@@ -9,6 +9,7 @@ import java.util.HashSet;
 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.classification.api.exceptions.ClassificationNotFoundException;
@@ -29,7 +30,7 @@ import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
 import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
 
 /**
- * Acceptance test for all "update workbasket" scenarios.
+ * Acceptance test for all "update workbasket authorizations" scenarios.
  */
 @ExtendWith(JaasExtension.class)
 class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
@@ -38,57 +39,10 @@ class UpdateWorkbasketAuthorizationsAccTest extends AbstractAccTest {
     super();
   }
 
+  @WithAccessId(user = "user_1_1")
   @WithAccessId(user = "taskadmin")
-  @Test
+  @TestTemplate
-  public void should_ThrowException_When_TaskAdminTriesToGetWorkbasketAccItem() {
+  public void should_ThrowException_When_UserIsNotAdminOrBusinessAdmin() {
-
-    final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable retrieveWorkbasketAccessItemCall =
-        () -> {
-          workbasketService.getWorkbasketAccessItems("WBI:100000000000000000000000000000000008");
-        };
-
-    assertThatThrownBy(retrieveWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  public void should_ThrowException_When_TaskAdminTriesToDeleteWorkbasketAccItemById() {
-
-    final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable deleteWorkbasketAccessItemCall =
-        () -> {
-          workbasketService.deleteWorkbasketAccessItemsForAccessId("group_1");
-        };
-
-    assertThatThrownBy(deleteWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  public void should_ThrowException_When_TaskAdminTriesToDeleteWorkbasketAccessItemByAccessId() {
-
-    final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    WorkbasketAccessItem workbasketAccessItem =
-        workbasketService.newWorkbasketAccessItem(
-            "WBI:100000000000000000000000000000000008", "newAccessIdForUpdate");
-
-    workbasketAccessItem.setPermCustom1(true);
-
-    ThrowingCallable deleteWorkbasketAccessItemCall =
-        () -> {
-          workbasketService.deleteWorkbasketAccessItem(workbasketAccessItem.getId());
-        };
-
-    assertThatThrownBy(deleteWorkbasketAccessItemCall).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  public void should_ThrowException_When_TaskAdminTriesToUpdateWorkbasketAccItem() {
 
     final WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();