diff --git a/lib/taskana-core-test/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java b/lib/taskana-core-test/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java
new file mode 100644
index 000000000..f0270bbd7
--- /dev/null
+++ b/lib/taskana-core-test/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java
@@ -0,0 +1,397 @@
+package acceptance.task.claim;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
+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.testapi.DefaultTestEntities.defaultTestWorkbasket;
+
+import java.time.Instant;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import pro.taskana.classification.api.ClassificationService;
+import pro.taskana.classification.api.models.ClassificationSummary;
+import pro.taskana.task.api.TaskService;
+import pro.taskana.task.api.TaskState;
+import pro.taskana.task.api.exceptions.InvalidOwnerException;
+import pro.taskana.task.api.models.ObjectReference;
+import pro.taskana.task.api.models.Task;
+import pro.taskana.testapi.TaskanaInject;
+import pro.taskana.testapi.TaskanaIntegrationTest;
+import pro.taskana.testapi.builder.TaskBuilder;
+import pro.taskana.testapi.builder.WorkbasketAccessItemBuilder;
+import pro.taskana.testapi.security.WithAccessId;
+import pro.taskana.workbasket.api.WorkbasketPermission;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
+import pro.taskana.workbasket.api.models.WorkbasketSummary;
+
+@TaskanaIntegrationTest
+class ClaimTaskAccTest {
+  @TaskanaInject TaskService taskService;
+  @TaskanaInject ClassificationService classificationService;
+  @TaskanaInject WorkbasketService workbasketService;
+
+  ClassificationSummary defaultClassificationSummary;
+  WorkbasketSummary defaultWorkbasketSummary;
+  ObjectReference defaultObjectReference;
+
+  @WithAccessId(user = "businessadmin")
+  @BeforeAll
+  void setup() throws Exception {
+    defaultClassificationSummary =
+        defaultTestClassification().buildAndStoreAsSummary(classificationService);
+    defaultWorkbasketSummary = defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
+
+    WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
+        .workbasketId(defaultWorkbasketSummary.getId())
+        .accessId("user-1-2")
+        .permission(WorkbasketPermission.OPEN)
+        .permission(WorkbasketPermission.READ)
+        .permission(WorkbasketPermission.APPEND)
+        .buildAndStore(workbasketService);
+
+    defaultObjectReference = defaultTestObjectReference().build();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ClaimTask_When_TaskIsReady() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task claimedTask = taskService.claim(task.getId());
+
+    assertThat(claimedTask).isNotNull();
+    assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
+    assertThat(claimedTask.getClaimed()).isNotNull();
+    assertThat(claimedTask.getModified())
+        .isNotEqualTo(claimedTask.getCreated())
+        .isEqualTo(claimedTask.getClaimed());
+    assertThat(claimedTask.isRead()).isTrue();
+    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ClaimTask_When_TaskIsReadyForReview() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.READY_FOR_REVIEW)
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task claimedTask = taskService.claim(task.getId());
+
+    assertThat(claimedTask).isNotNull();
+    assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
+    assertThat(claimedTask.getClaimed()).isNotNull();
+    assertThat(claimedTask.getModified())
+        .isNotEqualTo(claimedTask.getCreated())
+        .isEqualTo(claimedTask.getClaimed());
+    assertThat(claimedTask.isRead()).isTrue();
+    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ThrowException_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    ThrowingCallable call = () -> taskService.claim(task.getId());
+
+    InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
+    assertThat(e.getTaskId()).isEqualTo(task.getId());
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ThrowException_When_TaskIsAlreadyInReviewByAnotherUser() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    ThrowingCallable call = () -> taskService.claim(task.getId());
+
+    InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
+    assertThat(e.getTaskId()).isEqualTo(task.getId());
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ClaimTask_When_AlreadyClaimedByCaller() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-2")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ClaimTask_When_AlreadyInReviewByCaller() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-2")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ForceClaimTask_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task claimedTask = taskService.forceClaim(task.getId());
+
+    assertThat(claimedTask).isNotNull();
+    assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
+    assertThat(claimedTask.getClaimed()).isNotNull();
+    assertThat(claimedTask.getModified())
+        .isNotEqualTo(claimedTask.getCreated())
+        .isEqualTo(claimedTask.getClaimed());
+    assertThat(claimedTask.isRead()).isTrue();
+    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ForceClaimTask_When_InReviewByAnotherUser() throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task claimedTask = taskService.forceClaim(task.getId());
+
+    assertThat(claimedTask).isNotNull();
+    assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
+    assertThat(claimedTask.getClaimed()).isNotNull();
+    assertThat(claimedTask.getModified())
+        .isNotEqualTo(claimedTask.getCreated())
+        .isEqualTo(claimedTask.getClaimed());
+    assertThat(claimedTask.isRead()).isTrue();
+    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
+  }
+
+  @WithAccessId(user = "user-taskrouter")
+  @Test
+  void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReady()
+      throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.READY)
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService, "user-1-2");
+
+    ThrowingCallable call = () -> taskService.claim(task.getId());
+
+    NotAuthorizedOnWorkbasketException e =
+        catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("user-taskrouter");
+    assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
+    assertThat(e.getRequiredPermissions()).containsExactlyInAnyOrder(WorkbasketPermission.READ);
+
+    ;
+  }
+
+  @WithAccessId(user = "user-taskrouter")
+  @Test
+  void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReadyForReview()
+      throws Exception {
+    Task task =
+        TaskBuilder.newTask()
+            .state(TaskState.READY_FOR_REVIEW)
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService, "user-1-2");
+
+    ThrowingCallable call = () -> taskService.claim(task.getId());
+
+    NotAuthorizedOnWorkbasketException e =
+        catchThrowableOfType(call, NotAuthorizedOnWorkbasketException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("user-taskrouter");
+    assertThat(e.getWorkbasketId()).isEqualTo(defaultWorkbasketSummary.getId());
+    assertThat(e.getRequiredPermissions()).containsExactlyInAnyOrder(WorkbasketPermission.READ);
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_CancelClaimTask_When_TaskIsClaimed() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-2")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task unclaimedTask = taskService.cancelClaim(claimedTask.getId());
+
+    assertThat(unclaimedTask).isNotNull();
+    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
+    assertThat(unclaimedTask.getClaimed()).isNull();
+    assertThat(unclaimedTask.isRead()).isTrue();
+    assertThat(unclaimedTask.getOwner()).isNull();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_CancelClaimTask_When_TaskIsInReview() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-2")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task unclaimedTask = taskService.cancelClaim(claimedTask.getId());
+
+    assertThat(unclaimedTask).isNotNull();
+    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
+    assertThat(unclaimedTask.getClaimed()).isNull();
+    assertThat(unclaimedTask.isRead()).isTrue();
+    assertThat(unclaimedTask.getOwner()).isNull();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ThrowException_When_CancelClaimingATaskClaimedByAnotherUser() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
+
+    InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("user-1-2");
+    assertThat(e.getTaskId()).isEqualTo(claimedTask.getId());
+  }
+
+  @WithAccessId(user = "taskadmin")
+  @Test
+  void should_ThrowException_When_CancelClaimingATaskInReviewByAnotherUser() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-2")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
+
+    InvalidOwnerException e = catchThrowableOfType(call, InvalidOwnerException.class);
+    assertThat(e.getCurrentUserId()).isEqualTo("taskadmin");
+    assertThat(e.getTaskId()).isEqualTo(claimedTask.getId());
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ForceCancelClaim_When_TaskClaimedByAnotherUser() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.CLAIMED)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task unclaimedTask = taskService.forceCancelClaim(claimedTask.getId());
+
+    assertThat(unclaimedTask).isNotNull();
+    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
+    assertThat(unclaimedTask.getClaimed()).isNull();
+    assertThat(unclaimedTask.isRead()).isTrue();
+    assertThat(unclaimedTask.getOwner()).isNull();
+  }
+
+  @WithAccessId(user = "user-1-2")
+  @Test
+  void should_ForceCancelClaimTask_When_InReviewByAnotherUser() throws Exception {
+    Task claimedTask =
+        TaskBuilder.newTask()
+            .state(TaskState.IN_REVIEW)
+            .claimed(Instant.now())
+            .owner("user-1-1")
+            .classificationSummary(defaultClassificationSummary)
+            .workbasketSummary(defaultWorkbasketSummary)
+            .primaryObjRef(defaultObjectReference)
+            .buildAndStore(taskService);
+
+    Task unclaimedTask = taskService.forceCancelClaim(claimedTask.getId());
+
+    assertThat(unclaimedTask).isNotNull();
+    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
+    assertThat(unclaimedTask.getClaimed()).isNull();
+    assertThat(unclaimedTask.isRead()).isTrue();
+    assertThat(unclaimedTask.getOwner()).isNull();
+  }
+}
diff --git a/lib/taskana-core/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java b/lib/taskana-core/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java
deleted file mode 100644
index ee3386ece..000000000
--- a/lib/taskana-core/src/test/java/acceptance/task/claim/ClaimTaskAccTest.java
+++ /dev/null
@@ -1,225 +0,0 @@
-package acceptance.task.claim;
-
-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;
-import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import pro.taskana.common.test.security.JaasExtension;
-import pro.taskana.common.test.security.WithAccessId;
-import pro.taskana.task.api.TaskService;
-import pro.taskana.task.api.TaskState;
-import pro.taskana.task.api.exceptions.InvalidOwnerException;
-import pro.taskana.task.api.models.Task;
-import pro.taskana.workbasket.api.exceptions.NotAuthorizedOnWorkbasketException;
-
-@ExtendWith(JaasExtension.class)
-class ClaimTaskAccTest extends AbstractAccTest {
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ClaimTask_When_TaskIsReady() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000025");
-
-    taskService.claim(task.getId());
-
-    Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000025");
-    assertThat(claimedTask).isNotNull();
-    assertThat(claimedTask.getState()).isEqualTo(TaskState.CLAIMED);
-    assertThat(claimedTask.getClaimed()).isNotNull();
-    assertThat(claimedTask.getModified())
-        .isNotEqualTo(claimedTask.getCreated())
-        .isEqualTo(claimedTask.getClaimed());
-    assertThat(claimedTask.isRead()).isTrue();
-    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ClaimTask_When_TaskIsReadyForReview() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:100000000000000000000000000000000025");
-
-    taskService.claim(task.getId());
-
-    Task claimedTask = taskService.getTask("TKI:100000000000000000000000000000000025");
-    assertThat(claimedTask).isNotNull();
-    assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
-    assertThat(claimedTask.getClaimed()).isNotNull();
-    assertThat(claimedTask.getModified())
-        .isNotEqualTo(claimedTask.getCreated())
-        .isEqualTo(claimedTask.getClaimed());
-    assertThat(claimedTask.isRead()).isTrue();
-    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ThrowException_When_TaskIsAlreadyClaimed() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000026");
-
-    ThrowingCallable call = () -> taskService.claim(task.getId());
-    assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ThrowException_When_TaskIsAlreadyInReviewByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:600000000000000000000000000000000028");
-
-    ThrowingCallable call = () -> taskService.claim(task.getId());
-    assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ClaimTask_When_AlreadyClaimedByCaller() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000027");
-
-    assertThat(task.getState()).isSameAs(TaskState.CLAIMED);
-    assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ClaimTask_When_AlreadyInReviewByCaller() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:200000000000000000000000000000000025");
-
-    assertThat(task.getState()).isSameAs(TaskState.IN_REVIEW);
-    assertThatCode(() -> taskService.claim(task.getId())).doesNotThrowAnyException();
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ForceClaimTask_When_TaskIsAlreadyClaimedByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:000000000000000000000000000000000028");
-
-    ThrowingCallable call = () -> taskService.claim(task.getId());
-    assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ForceClaimTask_When_InReviewByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:200000000000000000000000000000000028");
-
-    Task claimedTask = taskService.forceClaim(task.getId());
-    assertThat(claimedTask).isNotNull();
-    assertThat(claimedTask.getState()).isEqualTo(TaskState.IN_REVIEW);
-    assertThat(claimedTask.getClaimed()).isNotNull();
-    assertThat(claimedTask.getModified())
-        .isNotEqualTo(claimedTask.getCreated())
-        .isEqualTo(claimedTask.getClaimed());
-    assertThat(claimedTask.isRead()).isTrue();
-    assertThat(claimedTask.getOwner()).isEqualTo("user-1-2");
-  }
-
-  @WithAccessId(user = "user-taskrouter")
-  @Test
-  void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReady() {
-    assertThatThrownBy(() -> taskService.claim("TKI:000000000000000000000000000000000000"))
-        .isInstanceOf(NotAuthorizedOnWorkbasketException.class);
-  }
-
-  @WithAccessId(user = "user-taskrouter")
-  @Test
-  void should_ThrowNotAuthorizedException_When_UserHasNoReadPermissionAndTaskIsReadyForReview() {
-    assertThatThrownBy(() -> taskService.claim("TKI:500000000000000000000000000000000028"))
-        .isInstanceOf(NotAuthorizedOnWorkbasketException.class);
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_CancelClaimTask_When_TaskIsClaimed() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
-
-    taskService.cancelClaim(claimedTask.getId());
-
-    Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000029");
-    assertThat(unclaimedTask).isNotNull();
-    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
-    assertThat(unclaimedTask.getClaimed()).isNull();
-    assertThat(unclaimedTask.isRead()).isTrue();
-    assertThat(unclaimedTask.getOwner()).isNull();
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_CancelClaimTask_When_TaskIsInReview() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
-
-    taskService.cancelClaim(claimedTask.getId());
-
-    Task unclaimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
-    assertThat(unclaimedTask).isNotNull();
-    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
-    assertThat(unclaimedTask.getClaimed()).isNull();
-    assertThat(unclaimedTask.isRead()).isTrue();
-    assertThat(unclaimedTask.getOwner()).isNull();
-
-    // Claim Task, so it can be used in a different test
-    taskService.claim(unclaimedTask.getId());
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ThrowException_When_CancelClaimingATaskClaimedByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000030");
-
-    ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
-    assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
-  }
-
-  @WithAccessId(user = "taskadmin")
-  @Test
-  void should_ThrowException_When_CancelClaimingATaskInReviewByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task claimedTask = taskService.getTask("TKI:200000000000000000000000000000000025");
-
-    ThrowingCallable call = () -> taskService.cancelClaim(claimedTask.getId());
-    assertThatThrownBy(call).isInstanceOf(InvalidOwnerException.class);
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ForceCancelClaim_When_TaskClaimedByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task claimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
-
-    taskService.forceCancelClaim(claimedTask.getId());
-
-    Task unclaimedTask = taskService.getTask("TKI:000000000000000000000000000000000031");
-    assertThat(unclaimedTask).isNotNull();
-    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY);
-    assertThat(unclaimedTask.getClaimed()).isNull();
-    assertThat(unclaimedTask.isRead()).isTrue();
-    assertThat(unclaimedTask.getOwner()).isNull();
-  }
-
-  @WithAccessId(user = "user-1-2")
-  @Test
-  void should_ForceCancelClaimTask_When_InReviewByAnotherUser() throws Exception {
-    TaskService taskService = taskanaEngine.getTaskService();
-    Task task = taskService.getTask("TKI:100000000000000000000000000000000028");
-
-    Task unclaimedTask = taskService.forceCancelClaim(task.getId());
-    assertThat(unclaimedTask).isNotNull();
-    assertThat(unclaimedTask.getState()).isEqualTo(TaskState.READY_FOR_REVIEW);
-    assertThat(unclaimedTask.getClaimed()).isNull();
-    assertThat(unclaimedTask.isRead()).isTrue();
-    assertThat(unclaimedTask.getOwner()).isNull();
-  }
-}