TSK-1814: structured acceptance tests in packages

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

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.create;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.delete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/classification/get/GetClassificationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.get;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/classification/query/ClassificationQueryAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.query;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static org.assertj.core.api.Assertions.assertThat;

lib/taskana-core/src/test/java/acceptance/classification/query/QueryClassificationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.query;
 
 import static java.lang.String.CASE_INSENSITIVE_ORDER;
 import static org.assertj.core.api.Assertions.assertThat;

lib/taskana-core/src/test/java/acceptance/classification/query/QueryClassificationWithPaginationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

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

@@ -1,4 +1,4 @@
-package acceptance.classification;
+package acceptance.classification.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;

lib/taskana-core/src/test/java/acceptance/security/TaskanaSecurityAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.security;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -16,9 +16,9 @@ import pro.taskana.common.test.security.WithAccessId;
 
 /** Acceptance test for task queries and authorization. */
 @ExtendWith(JaasExtension.class)
-class TaskEngineAccTest extends AbstractAccTest {
+class TaskanaSecurityAccTest extends AbstractAccTest {
 
-  TaskEngineAccTest() {
+  TaskanaSecurityAccTest() {
     super();
   }
 

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

@@ -1,56 +0,0 @@
-package acceptance.task;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import acceptance.AbstractAccTest;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-
-import pro.taskana.common.api.BulkOperationResults;
-import pro.taskana.common.api.exceptions.TaskanaException;
-import pro.taskana.common.test.security.JaasExtension;
-import pro.taskana.common.test.security.WithAccessId;
-import pro.taskana.task.api.models.Task;
-import pro.taskana.task.api.models.TaskSummary;
-
-/** Acceptance test for planned and prio of all tasks. */
-@ExtendWith(JaasExtension.class)
-class ServiceLevelOfAllTasksAccTest extends AbstractAccTest {
-
-  @WithAccessId(user = "admin")
-  @Test
-  void testSetPlannedPropertyOnAllTasks() throws Exception {
-    Instant planned = getInstant("2020-05-03T07:00:00");
-    List<TaskSummary> allTasks = taskService.createTaskQuery().list();
-    // Now update each task with updateTask() and new planned
-    final List<TaskSummary> individuallyUpdatedTasks = new ArrayList<>();
-    allTasks.forEach(t -> individuallyUpdatedTasks.add(getUpdatedTaskSummary(t, planned)));
-    // reset DB and do the same with bulk update
-    resetDb(false);
-    List<String> taskIds = allTasks.stream().map(TaskSummary::getId).collect(Collectors.toList());
-    BulkOperationResults<String, TaskanaException> bulkLog =
-        taskService.setPlannedPropertyOfTasks(planned, taskIds);
-    // check that there was no error and compare the result of the 2 operations
-    assertThat(bulkLog.containsErrors()).isFalse();
-    Map<String, Instant> bulkUpdatedTaskMap =
-        taskService.createTaskQuery().list().stream()
-            .collect(Collectors.toMap(TaskSummary::getId, TaskSummary::getDue));
-    individuallyUpdatedTasks.forEach(
-        t -> assertThat(t.getDue().equals(bulkUpdatedTaskMap.get(t.getId()))));
-  }
-
-  private TaskSummary getUpdatedTaskSummary(TaskSummary t, Instant planned) {
-    try {
-      Task task = taskService.getTask(t.getId());
-      task.setPlanned(planned);
-      return taskService.updateTask(task);
-    } catch (Exception e) {
-      return null;
-    }
-  }
-}

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

@@ -12,6 +12,8 @@ import java.time.ZoneId;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.assertj.core.data.TemporalUnitWithinOffset;
 import org.junit.jupiter.api.Test;
@@ -29,6 +31,7 @@ import pro.taskana.common.test.security.WithAccessId;
 import pro.taskana.task.api.TaskService;
 import pro.taskana.task.api.exceptions.TaskNotFoundException;
 import pro.taskana.task.api.models.Task;
+import pro.taskana.task.api.models.TaskSummary;
 
 /** Acceptance test for all "create task" scenarios. */
 @ExtendWith(JaasExtension.class)
@@ -600,4 +603,38 @@ class ServiceLevelPriorityAccTest extends AbstractAccTest {
     assertThat(task.getDue()).isEqualTo(getInstant("2020-04-14T07:00:00")); // Tuesday
     assertThat(task.getPlanned()).isEqualTo(getInstant("2020-04-09T07:00:00")); // Thursday
   }
+
+  @WithAccessId(user = "admin")
+  @Test
+  void testSetPlannedPropertyOnAllTasks() throws Exception {
+    resetDb(false);
+
+    Instant planned = getInstant("2020-05-03T07:00:00");
+    List<TaskSummary> allTasks = taskService.createTaskQuery().list();
+    // Now update each task with updateTask() and new planned
+    final List<TaskSummary> individuallyUpdatedTasks = new ArrayList<>();
+    allTasks.forEach(t -> individuallyUpdatedTasks.add(getUpdatedTaskSummary(t, planned)));
+    // reset DB and do the same with bulk update
+    resetDb(false);
+    List<String> taskIds = allTasks.stream().map(TaskSummary::getId).collect(Collectors.toList());
+    BulkOperationResults<String, TaskanaException> bulkLog =
+        taskService.setPlannedPropertyOfTasks(planned, taskIds);
+    // check that there was no error and compare the result of the 2 operations
+    assertThat(bulkLog.containsErrors()).isFalse();
+    Map<String, Instant> bulkUpdatedTaskMap =
+        taskService.createTaskQuery().list().stream()
+            .collect(Collectors.toMap(TaskSummary::getId, TaskSummary::getDue));
+    individuallyUpdatedTasks.forEach(
+        t -> assertThat(t.getDue().equals(bulkUpdatedTaskMap.get(t.getId()))));
+  }
+
+  private TaskSummary getUpdatedTaskSummary(TaskSummary t, Instant planned) {
+    try {
+      Task task = taskService.getTask(t.getId());
+      task.setPlanned(planned);
+      return taskService.updateTask(task);
+    } catch (Exception e) {
+      return null;
+    }
+  }
 }

lib/taskana-core/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.claim;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
@@ -25,7 +25,7 @@ import pro.taskana.task.api.models.Task;
 
 /** Acceptance test for all "work on task" scenarios. This includes claim, complete... */
 @ExtendWith(JaasExtension.class)
-class WorkOnTaskAccTest extends AbstractAccTest {
+class ClaimTaskAccTest extends AbstractAccTest {
 
   @WithAccessId(user = "user-1-2")
   @Test

lib/taskana-core/src/test/java/acceptance/task/claim/SelectAndClaimTaskAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.claim;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/claim/SetOwnerAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.claim;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.complete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.complete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.complete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.create;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/create/CreateTaskWithSorAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.create;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.delete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/delete/DeleteTaskWithSorAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.delete;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.get;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;

lib/taskana-core/src/test/java/acceptance/task/get/GetTaskWithSorAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.get;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferenceAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.objectreference;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static pro.taskana.task.api.ObjectReferenceQueryColumnName.COMPANY;

lib/taskana-core/src/test/java/acceptance/task/query/QueryObjectReferencesWithPaginationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.objectreference;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByRoleAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByTimeIntervalsAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByWildcardSearchAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksByWorkbasketAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksListValuesAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksWithPaginationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;

lib/taskana-core/src/test/java/acceptance/task/query/QueryTasksWithSortingAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static java.lang.String.CASE_INSENSITIVE_ORDER;
 import static org.assertj.core.api.Assertions.assertThat;

lib/taskana-core/src/test/java/acceptance/task/query/TaskQueryImplAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.query;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.transfer;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;

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

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;

lib/taskana-core/src/test/java/acceptance/task/update/UpdateTaskAttachmentsAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/task/update/UpdateTaskWithSorAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.task.update;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

lib/taskana-core/src/test/java/acceptance/taskcomment/create/CreateTaskCommentAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.taskcomment.create;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/taskcomment/delete/DeleteTaskCommentAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.taskcomment.delete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/taskcomment/get/GetTaskCommentAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.taskcomment.get;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/taskcomment/query/QueryTaskCommentAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.taskcomment.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/taskcomment/update/UpdateTaskCommentAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.task;
+package acceptance.taskcomment.update;
 
 import static acceptance.DefaultTestEntities.defaultTestClassification;
 import static acceptance.DefaultTestEntities.defaultTestObjectReference;

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

@@ -1,248 +0,0 @@
-package acceptance.workbasket;
-
-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 static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.lenient;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import pro.taskana.TaskanaEngineConfiguration;
-import pro.taskana.common.api.TaskanaEngine;
-import pro.taskana.common.api.exceptions.ConcurrencyException;
-import pro.taskana.common.internal.InternalTaskanaEngine;
-import pro.taskana.spi.history.internal.HistoryEventManager;
-import pro.taskana.task.api.TaskQuery;
-import pro.taskana.task.api.TaskService;
-import pro.taskana.workbasket.api.WorkbasketType;
-import pro.taskana.workbasket.api.exceptions.WorkbasketAccessItemAlreadyExistException;
-import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
-import pro.taskana.workbasket.api.models.Workbasket;
-import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
-import pro.taskana.workbasket.internal.DistributionTargetMapper;
-import pro.taskana.workbasket.internal.WorkbasketAccessMapper;
-import pro.taskana.workbasket.internal.WorkbasketMapper;
-import pro.taskana.workbasket.internal.WorkbasketServiceImpl;
-import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
-import pro.taskana.workbasket.internal.models.WorkbasketImpl;
-
-/** Unit Test for workbasketServiceImpl. */
-@ExtendWith(MockitoExtension.class)
-class WorkbasketServiceImplTest {
-
-  @Spy @InjectMocks private WorkbasketServiceImpl workbasketServiceSpy;
-
-  @Mock private WorkbasketMapper workbasketMapperMock;
-
-  @Mock private DistributionTargetMapper distributionTargetMapperMock;
-
-  @Mock private WorkbasketAccessMapper workbasketAccessMapperMock;
-
-  @Mock private TaskService taskServiceMock;
-
-  @Mock private TaskQuery taskQueryMock;
-
-  @Mock private TaskanaEngine taskanaEngine;
-
-  @Mock private InternalTaskanaEngine internalTaskanaEngineMock;
-
-  @Mock private TaskanaEngineConfiguration taskanaEngineConfigurationMock;
-
-  @Mock private HistoryEventManager historyEventManager;
-
-  @BeforeEach
-  void setup() {
-    lenient().when(internalTaskanaEngineMock.getEngine()).thenReturn(taskanaEngine);
-    lenient().when(historyEventManager.isEnabled()).thenReturn(false);
-  }
-
-  @Test
-  void testCreateWorkbasket_WithDistributionTargets() throws Exception {
-    final int distTargetAmount = 2;
-    WorkbasketImpl expectedWb = createTestWorkbasket(null, "Key-1");
-    doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(any());
-    when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
-
-    final Workbasket actualWb = workbasketServiceSpy.createWorkbasket(expectedWb);
-    workbasketServiceSpy.setDistributionTargets(
-        expectedWb.getId(), createTestDistributionTargets(distTargetAmount));
-
-    verify(internalTaskanaEngineMock, times(4)).openConnection();
-    verify(workbasketMapperMock, times(3)).insert(any());
-    verify(workbasketServiceSpy, times(distTargetAmount + 1)).getWorkbasket(any());
-    verify(distributionTargetMapperMock, times(1)).deleteAllDistributionTargetsBySourceId(any());
-    verify(distributionTargetMapperMock, times(distTargetAmount)).insert(any(), any());
-    verify(workbasketMapperMock, times(3)).findByKeyAndDomain(any(), any());
-    verify(workbasketMapperMock, times(1)).update(any());
-    verify(internalTaskanaEngineMock, times(4)).returnConnection();
-    verify(taskanaEngine, times(4)).checkRoleMembership(any());
-    verify(internalTaskanaEngineMock, times(4)).getEngine();
-    verify(internalTaskanaEngineMock, times(3)).domainExists(any());
-    verify(historyEventManager, times(5)).isEnabled();
-    verifyNoMoreInteractions(
-        taskQueryMock,
-        taskServiceMock,
-        workbasketMapperMock,
-        workbasketAccessMapperMock,
-        distributionTargetMapperMock,
-        internalTaskanaEngineMock,
-        taskanaEngine,
-        taskanaEngineConfigurationMock);
-    assertThat(actualWb.getId()).isNotNull();
-    assertThat(actualWb.getId()).startsWith("WBI");
-    assertThat(actualWb.getCreated()).isNotNull();
-    assertThat(actualWb.getModified()).isNotNull();
-  }
-
-  @Test
-  void testCreateWorkbasket_DistributionTargetNotExisting() throws Exception {
-    WorkbasketImpl expectedWb = createTestWorkbasket("ID-1", "Key-1");
-    when(internalTaskanaEngineMock.domainExists(any())).thenReturn(true);
-    String otherWorkbasketId = "4711";
-    List<String> destinations = List.of(otherWorkbasketId);
-    workbasketServiceSpy.createWorkbasket(expectedWb);
-    doReturn(expectedWb).when(workbasketServiceSpy).getWorkbasket(expectedWb.getId());
-
-    ThrowingCallable call =
-        () -> {
-          workbasketServiceSpy.setDistributionTargets(expectedWb.getId(), destinations);
-        };
-    assertThatThrownBy(call)
-        .isInstanceOf(WorkbasketNotFoundException.class)
-        .hasFieldOrPropertyWithValue("id", otherWorkbasketId)
-        .hasFieldOrPropertyWithValue("key", null)
-        .hasFieldOrPropertyWithValue("domain", null);
-
-    verify(internalTaskanaEngineMock, times(3)).openConnection();
-    verify(workbasketMapperMock, times(1)).insert(expectedWb);
-    verify(workbasketMapperMock, times(1)).findById(any());
-    verify(workbasketMapperMock, times(1)).findByKeyAndDomain(any(), any());
-    verify(workbasketServiceSpy, times(2)).getWorkbasket(any());
-    verify(internalTaskanaEngineMock, times(3)).returnConnection();
-    verify(taskanaEngine, times(2)).checkRoleMembership(any());
-    verify(internalTaskanaEngineMock, times(2)).getEngine();
-    verify(internalTaskanaEngineMock, times(1)).domainExists(any());
-    verify(distributionTargetMapperMock).deleteAllDistributionTargetsBySourceId(expectedWb.getId());
-    verify(workbasketMapperMock).update(expectedWb);
-    verify(historyEventManager, times(2)).isEnabled();
-
-    verifyNoMoreInteractions(
-        taskQueryMock,
-        taskServiceMock,
-        workbasketMapperMock,
-        workbasketAccessMapperMock,
-        distributionTargetMapperMock,
-        internalTaskanaEngineMock,
-        taskanaEngine,
-        taskanaEngineConfigurationMock);
-  }
-
-  @Test
-  void testDeleteWorkbasketIsUsed() throws Exception {
-    Workbasket wb = createTestWorkbasket("WBI:0", "wb-key");
-
-    ThrowingCallable call =
-        () -> {
-          workbasketServiceSpy.deleteWorkbasket(wb.getId());
-        };
-    assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
-
-    verify(internalTaskanaEngineMock, times(2)).openConnection();
-    verify(workbasketServiceSpy, times(1)).getWorkbasket(wb.getId());
-    verify(taskanaEngine, times(0)).getTaskService();
-    verify(taskServiceMock, times(0)).createTaskQuery();
-    verify(taskQueryMock, times(0)).workbasketIdIn(wb.getId());
-    verify(taskQueryMock, times(0)).count();
-    verify(internalTaskanaEngineMock, times(2)).returnConnection();
-    verifyNoMoreInteractions(
-        taskQueryMock,
-        taskServiceMock,
-        workbasketAccessMapperMock,
-        distributionTargetMapperMock,
-        taskanaEngineConfigurationMock);
-  }
-
-  @Test
-  void testSetWorkbasketAccessItemsWithMultipleAccessIds() {
-
-    String wid = "workbasketId";
-    List<WorkbasketAccessItem> accessItems =
-        IntStream.rangeClosed(0, 10)
-            .mapToObj(i -> createWorkbasketAccessItem("id" + i, "access" + i, wid))
-            .collect(Collectors.toList());
-    accessItems.add(createWorkbasketAccessItem("id5", "access5", wid));
-
-    assertThatThrownBy(() -> workbasketServiceSpy.setWorkbasketAccessItems(wid, accessItems))
-        .isInstanceOf(WorkbasketAccessItemAlreadyExistException.class);
-  }
-
-  @Test
-  void testCheckModifiedHasNotChanged() {
-
-    Instant expectedModifiedTimestamp = Instant.now();
-
-    WorkbasketImpl oldWb = createTestWorkbasket(null, "Key-1");
-    WorkbasketImpl workbasketImplToUpdate = createTestWorkbasket(null, "Key-2");
-    oldWb.setModified(expectedModifiedTimestamp);
-    workbasketImplToUpdate.setModified(expectedModifiedTimestamp);
-
-    ThrowingCallable call =
-        () -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate);
-    assertThatCode(call).doesNotThrowAnyException();
-
-    workbasketImplToUpdate.setModified(expectedModifiedTimestamp.minus(1, ChronoUnit.HOURS));
-
-    call = () -> workbasketServiceSpy.checkModifiedHasNotChanged(oldWb, workbasketImplToUpdate);
-    assertThatThrownBy(call).isInstanceOf(ConcurrencyException.class);
-  }
-
-  private WorkbasketImpl createTestWorkbasket(String id, String key) {
-    WorkbasketImpl workbasket = new WorkbasketImpl();
-    workbasket.setId(id);
-    workbasket.setKey(key);
-    workbasket.setName("Workbasket " + id);
-    workbasket.setDescription("Description WB with Key " + key);
-    workbasket.setType(WorkbasketType.PERSONAL);
-    workbasket.setDomain("DOMAIN_A");
-    return workbasket;
-  }
-
-  private List<String> createTestDistributionTargets(int amount) throws Exception {
-    List<String> distributionsTargets = new ArrayList<>();
-    amount = Math.max(amount, 0);
-    for (int i = 0; i < amount; i++) {
-      WorkbasketImpl wb = createTestWorkbasket("WB-ID-" + i, "WB-KEY-" + i);
-      workbasketServiceSpy.createWorkbasket(wb);
-      distributionsTargets.add(wb.getId());
-    }
-    return distributionsTargets;
-  }
-
-  private WorkbasketAccessItem createWorkbasketAccessItem(
-      String id, String accessId, String workbasketId) {
-    WorkbasketAccessItemImpl workbasketAccessItem = new WorkbasketAccessItemImpl();
-    workbasketAccessItem.setId(id);
-    workbasketAccessItem.setAccessId(accessId);
-    workbasketAccessItem.setWorkbasketId(workbasketId);
-    return workbasketAccessItem;
-  }
-}

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.create;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.create;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.delete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.delete;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/workbasket/get/GetDistributionTargetsAccTest.java

@@ -0,0 +1,182 @@
+package acceptance.workbasket.get;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+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;
+import pro.taskana.common.test.security.JaasExtension;
+import pro.taskana.common.test.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
+import pro.taskana.workbasket.api.models.WorkbasketSummary;
+
+/** Acceptance test for all "get workbasket" scenarios. */
+@ExtendWith(JaasExtension.class)
+class GetDistributionTargetsAccTest extends AbstractAccTest {
+
+  GetDistributionTargetsAccTest() {
+    super();
+  }
+
+  @WithAccessId(user = "businessadmin")
+  @Test
+  void should_ReturnDistributionTargets_When_QueriedById() throws Exception {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    WorkbasketSummary workbasketSummary =
+        workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
+    List<String> expectedTargetIds =
+        List.of(
+            "WBI:100000000000000000000000000000000002",
+            "WBI:100000000000000000000000000000000003",
+            "WBI:100000000000000000000000000000000004",
+            "WBI:100000000000000000000000000000000005");
+
+    List<WorkbasketSummary> retrievedDistributionTargets =
+        workbasketService.getDistributionTargets(workbasketSummary.getId());
+
+    assertThat(retrievedDistributionTargets)
+        .extracting(WorkbasketSummary::getId)
+        .containsExactlyInAnyOrderElementsOf(expectedTargetIds);
+  }
+
+  @WithAccessId(user = "businessadmin")
+  @Test
+  void should_ReturnDistributionTargets_When_QueriedByKeyDomain() throws Exception {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    WorkbasketSummary workbasketSummary =
+        workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
+    List<String> expectedTargetIds =
+        List.of(
+            "WBI:100000000000000000000000000000000002",
+            "WBI:100000000000000000000000000000000003",
+            "WBI:100000000000000000000000000000000004",
+            "WBI:100000000000000000000000000000000005");
+
+    List<WorkbasketSummary> retrievedDistributionTargets =
+        workbasketService.getDistributionTargets(
+            workbasketSummary.getKey(), workbasketSummary.getDomain());
+
+    assertThat(retrievedDistributionTargets)
+        .extracting(WorkbasketSummary::getId)
+        .containsExactlyInAnyOrderElementsOf(expectedTargetIds);
+  }
+
+  @WithAccessId(user = "businessadmin")
+  @Test
+  void should_ThrowException_When_QueriedWithInvalidWorkbasket() throws Exception {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    String existingWb = "WBI:100000000000000000000000000000000001";
+    String nonExistingWb = "WBI:100000000000000000000000000000000xx1";
+
+    ThrowingCallable call =
+        () -> {
+          workbasketService.getDistributionTargets("WBI:100000000000000000000000000000000xx1");
+        };
+    assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
+
+    call =
+        () -> {
+          workbasketService.getDistributionTargets("NOT_EXUTSING", "NOT_EXUTSING");
+        };
+    assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
+  }
+
+  @WithAccessId(user = "admin")
+  @WithAccessId(user = "businessadmin")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  void should_ReturnDistributionTargets_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
+      throws Exception {
+
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    String existingWb = "WBI:100000000000000000000000000000000001";
+
+    List<WorkbasketSummary> distributionTargets =
+        workbasketService.getDistributionTargets(existingWb);
+    assertThat(distributionTargets).hasSize(4);
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @WithAccessId(user = "taskadmin")
+  @TestTemplate
+  void should_ThrowException_When_UserRoleIsNotAdminOrBusinessAdminAndMakesDistTargetCalls() {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    String existingWb = "WBI:100000000000000000000000000000000001";
+
+    ThrowingCallable call =
+        () -> {
+          workbasketService.setDistributionTargets(
+              existingWb, List.of("WBI:100000000000000000000000000000000002"));
+        };
+    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
+  }
+
+  @WithAccessId(user = "user-1-1")
+  @Test
+  void should_ThrowException_When_UserTriesToGetDistributionTargetsAndRoleIsNotAdministrative() {
+
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+    String existingWb = "WBI:100000000000000000000000000000000001";
+
+    ThrowingCallable getDistributionTargetsCall =
+        () -> {
+          workbasketService.getDistributionTargets(existingWb);
+        };
+    assertThatThrownBy(getDistributionTargetsCall).isInstanceOf(NotAuthorizedException.class);
+  }
+
+  @WithAccessId(user = "businessadmin")
+  @Test
+  void testGetDistributionSourcesById() throws Exception {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    List<WorkbasketSummary> distributionSources =
+        workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
+
+    assertThat(distributionSources)
+        .extracting(WorkbasketSummary::getId)
+        .containsExactlyInAnyOrder(
+            "WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
+  }
+
+  @WithAccessId(user = "teamlead-1")
+  @Test
+  void testGetDistributionSourcesByKeyDomain() throws Exception {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    List<WorkbasketSummary> distributionSources =
+        workbasketService.getDistributionSources("TEAMLEAD-1", "DOMAIN_A");
+
+    assertThat(distributionSources)
+        .extracting(WorkbasketSummary::getId)
+        .containsExactlyInAnyOrder(
+            "WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
+  }
+
+  @WithAccessId(user = "unknownuser")
+  @Test
+  void testGetDistributionSourcesThrowsNotAuthorized() {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    ThrowingCallable call =
+        () -> workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
+    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
+  }
+
+  @WithAccessId(user = "user-2-2")
+  @Test
+  void testGetDistributionSourcesThrowsWorkbasketNotFound() {
+    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
+
+    ThrowingCallable call =
+        () -> workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004");
+    assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
+  }
+}

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.get;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.get;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 

lib/taskana-core/src/test/java/acceptance/workbasket/query/QueryWorkbasketAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static java.lang.String.CASE_INSENSITIVE_ORDER;
 import static org.assertj.core.api.Assertions.assertThat;

lib/taskana-core/src/test/java/acceptance/workbasket/query/QueryWorkbasketAccessItemsAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static java.lang.String.CASE_INSENSITIVE_ORDER;
 import static org.assertj.core.api.Assertions.assertThat;

lib/taskana-core/src/test/java/acceptance/workbasket/query/QueryWorkbasketByPermissionAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/workbasket/query/QueryWorkbasketsWithPaginationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

lib/taskana-core/src/test/java/acceptance/workbasket/query/WorkbasketQueryAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;

lib/taskana-core/src/test/java/acceptance/workbasket/query/WorkbasketQueryWithOrderedPaginationAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.query;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

lib/taskana-core/src/test/java/acceptance/workbasket/update/UpdateDistributionTargetsAccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -21,55 +21,12 @@ import pro.taskana.workbasket.api.models.WorkbasketSummary;
 
 /** Acceptance test for all "get workbasket" scenarios. */
 @ExtendWith(JaasExtension.class)
-class DistributionTargetsAccTest extends AbstractAccTest {
+class UpdateDistributionTargetsAccTest extends AbstractAccTest {
 
-  DistributionTargetsAccTest() {
+  UpdateDistributionTargetsAccTest() {
     super();
   }
 
-  @WithAccessId(user = "businessadmin")
-  @Test
-  void testGetDistributionTargetsSucceedsById() throws Exception {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    WorkbasketSummary workbasketSummary =
-        workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
-    List<String> expectedTargetIds =
-        List.of(
-            "WBI:100000000000000000000000000000000002",
-            "WBI:100000000000000000000000000000000003",
-            "WBI:100000000000000000000000000000000004",
-            "WBI:100000000000000000000000000000000005");
-
-    List<WorkbasketSummary> retrievedDistributionTargets =
-        workbasketService.getDistributionTargets(workbasketSummary.getId());
-
-    assertThat(retrievedDistributionTargets)
-        .extracting(WorkbasketSummary::getId)
-        .containsExactlyInAnyOrderElementsOf(expectedTargetIds);
-  }
-
-  @WithAccessId(user = "businessadmin")
-  @Test
-  void testGetDistributionTargetsSucceeds() throws Exception {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    WorkbasketSummary workbasketSummary =
-        workbasketService.createWorkbasketQuery().keyIn("GPK_KSC").single();
-    List<String> expectedTargetIds =
-        List.of(
-            "WBI:100000000000000000000000000000000002",
-            "WBI:100000000000000000000000000000000003",
-            "WBI:100000000000000000000000000000000004",
-            "WBI:100000000000000000000000000000000005");
-
-    List<WorkbasketSummary> retrievedDistributionTargets =
-        workbasketService.getDistributionTargets(
-            workbasketSummary.getKey(), workbasketSummary.getDomain());
-
-    assertThat(retrievedDistributionTargets)
-        .extracting(WorkbasketSummary::getId)
-        .containsExactlyInAnyOrderElementsOf(expectedTargetIds);
-  }
-
   @WithAccessId(user = "businessadmin")
   @Test
   void testDistributionTargetCallsWithNonExistingWorkbaskets() throws Exception {
@@ -99,21 +56,6 @@ class DistributionTargetsAccTest extends AbstractAccTest {
     assertThat(beforeCount).isEqualTo(afterCount);
   }
 
-  @WithAccessId(user = "admin")
-  @WithAccessId(user = "businessadmin")
-  @WithAccessId(user = "taskadmin")
-  @TestTemplate
-  void should_ReturnDistributionTargets_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
-      throws Exception {
-
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    String existingWb = "WBI:100000000000000000000000000000000001";
-
-    List<WorkbasketSummary> distributionTargets =
-        workbasketService.getDistributionTargets(existingWb);
-    assertThat(distributionTargets).hasSize(4);
-  }
-
   @WithAccessId(user = "user-1-1")
   @WithAccessId(user = "taskadmin")
   @TestTemplate
@@ -143,20 +85,6 @@ class DistributionTargetsAccTest extends AbstractAccTest {
     assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
   }
 
-  @WithAccessId(user = "user-1-1")
-  @Test
-  void should_ThrowException_When_UserTriesToGetDistributionTargetsAndRoleIsNotAdministrative() {
-
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    String existingWb = "WBI:100000000000000000000000000000000001";
-
-    ThrowingCallable getDistributionTargetsCall =
-        () -> {
-          workbasketService.getDistributionTargets(existingWb);
-        };
-    assertThatThrownBy(getDistributionTargetsCall).isInstanceOf(NotAuthorizedException.class);
-  }
-
   @WithAccessId(user = "businessadmin")
   @Test
   void testAddAndRemoveDistributionTargets() throws Exception {
@@ -254,52 +182,4 @@ class DistributionTargetsAccTest extends AbstractAccTest {
     // reset DB to original state
     resetDb(false);
   }
-
-  @WithAccessId(user = "businessadmin")
-  @Test
-  void testGetDistributionSourcesById() throws Exception {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    List<WorkbasketSummary> distributionSources =
-        workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
-
-    assertThat(distributionSources)
-        .extracting(WorkbasketSummary::getId)
-        .containsExactlyInAnyOrder(
-            "WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
-  }
-
-  @WithAccessId(user = "teamlead-1")
-  @Test
-  void testGetDistributionSourcesByKeyDomain() throws Exception {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    List<WorkbasketSummary> distributionSources =
-        workbasketService.getDistributionSources("TEAMLEAD-1", "DOMAIN_A");
-
-    assertThat(distributionSources)
-        .extracting(WorkbasketSummary::getId)
-        .containsExactlyInAnyOrder(
-            "WBI:100000000000000000000000000000000001", "WBI:100000000000000000000000000000000002");
-  }
-
-  @WithAccessId(user = "unknownuser")
-  @Test
-  void testQueryDistributionSourcesThrowsNotAuthorized() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable call =
-        () -> workbasketService.getDistributionSources("WBI:100000000000000000000000000000000004");
-    assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
-  }
-
-  @WithAccessId(user = "user-2-2")
-  @Test
-  void testQueryDistributionSourcesThrowsWorkbasketNotFound() {
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-
-    ThrowingCallable call =
-        () -> workbasketService.getDistributionSources("WBI:10dasgibtsdochnicht00000000000000004");
-    assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
-  }
 }

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;

lib/taskana-core/src/test/java/acceptance/workbasket/update/UpdateWorkbasketAuthorizations2AccTest.java

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 

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

@@ -1,4 +1,4 @@
-package acceptance.workbasket;
+package acceptance.workbasket.update;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;