TSK-1633: new dependency injection extension replaces AbstractAccTest

Co-authored-by: SebastianRoseneck <55637012+SebastianRoseneck@users.noreply.github.com>

lib/taskana-core/src/test/java/acceptance/FooBar.java

@@ -1,21 +0,0 @@
-package acceptance;
-
-import javax.sql.DataSource;
-
-import pro.taskana.TaskanaEngineConfiguration;
-import pro.taskana.common.api.TaskanaEngine;
-import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
-import pro.taskana.common.test.config.DataSourceGenerator;
-
-public class FooBar {
-  public static TaskanaEngine getTaskanaEngineForTests() throws Exception {
-    DataSource dataSource = DataSourceGenerator.getDataSource();
-    String schemaName = DataSourceGenerator.getSchemaName();
-    TaskanaEngineConfiguration taskanaEngineConfiguration =
-        new TaskanaEngineConfiguration(dataSource, false, schemaName);
-    taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(true);
-    TaskanaEngine taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
-    taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
-    return taskanaEngine;
-  }
-}

lib/taskana-core/src/test/java/acceptance/TaskanaDependencyInjectionExtension.java

@@ -0,0 +1,69 @@
+package acceptance;
+
+import java.util.Map;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+import org.junit.platform.commons.JUnitException;
+
+import pro.taskana.TaskanaEngineConfiguration;
+import pro.taskana.classification.internal.ClassificationServiceImpl;
+import pro.taskana.common.api.TaskanaEngine;
+import pro.taskana.common.api.TaskanaEngine.ConnectionManagementMode;
+import pro.taskana.common.api.WorkingDaysToDaysConverter;
+import pro.taskana.common.internal.JobServiceImpl;
+import pro.taskana.common.internal.TaskanaEngineImpl;
+import pro.taskana.common.test.config.DataSourceGenerator;
+import pro.taskana.monitor.internal.MonitorServiceImpl;
+import pro.taskana.task.internal.TaskServiceImpl;
+import pro.taskana.workbasket.internal.WorkbasketServiceImpl;
+
+public class TaskanaDependencyInjectionExtension implements ParameterResolver {
+
+  private final Map<Class<?>, Object> instanceByClass;
+
+  public TaskanaDependencyInjectionExtension(DataSource dataSource) throws Exception {
+    String schemaName = DataSourceGenerator.getSchemaName();
+    TaskanaEngineConfiguration taskanaEngineConfiguration =
+        new TaskanaEngineConfiguration(dataSource, false, schemaName);
+    taskanaEngineConfiguration.setGermanPublicHolidaysEnabled(true);
+    TaskanaEngine taskanaEngine = taskanaEngineConfiguration.buildTaskanaEngine();
+    taskanaEngine.setConnectionManagementMode(ConnectionManagementMode.AUTOCOMMIT);
+    instanceByClass =
+        Map.ofEntries(
+            Map.entry(TaskanaEngineConfiguration.class, taskanaEngineConfiguration),
+            Map.entry(TaskanaEngineImpl.class, taskanaEngine),
+            Map.entry(TaskServiceImpl.class, taskanaEngine.getTaskService()),
+            Map.entry(MonitorServiceImpl.class, taskanaEngine.getMonitorService()),
+            Map.entry(WorkbasketServiceImpl.class, taskanaEngine.getWorkbasketService()),
+            Map.entry(ClassificationServiceImpl.class, taskanaEngine.getClassificationService()),
+            Map.entry(JobServiceImpl.class, taskanaEngine.getJobService()),
+            Map.entry(
+                WorkingDaysToDaysConverter.class, taskanaEngine.getWorkingDaysToDaysConverter()));
+  }
+
+  @Override
+  public boolean supportsParameter(
+      ParameterContext parameterContext, ExtensionContext extensionContext)
+      throws ParameterResolutionException {
+    return instanceByClass.keySet().stream()
+        .anyMatch(getParameterType(parameterContext)::isAssignableFrom);
+  }
+
+  @Override
+  public Object resolveParameter(
+      ParameterContext parameterContext, ExtensionContext extensionContext)
+      throws ParameterResolutionException {
+    return instanceByClass.keySet().stream()
+        .filter(getParameterType(parameterContext)::isAssignableFrom)
+        .map(instanceByClass::get)
+        .findFirst()
+        .orElseThrow(() -> new JUnitException("This should never happen."));
+  }
+
+  private Class<?> getParameterType(ParameterContext parameterContext) {
+    return parameterContext.getParameter().getType();
+  }
+}

lib/taskana-core/src/test/java/acceptance/TaskanaDependencyInjectionExtensionTest.java

@@ -0,0 +1,185 @@
+package acceptance;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import pro.taskana.TaskanaEngineConfiguration;
+import pro.taskana.classification.api.ClassificationService;
+import pro.taskana.classification.internal.ClassificationServiceImpl;
+import pro.taskana.common.api.JobService;
+import pro.taskana.common.api.TaskanaEngine;
+import pro.taskana.common.api.WorkingDaysToDaysConverter;
+import pro.taskana.common.internal.JobServiceImpl;
+import pro.taskana.common.internal.TaskanaEngineImpl;
+import pro.taskana.monitor.api.MonitorService;
+import pro.taskana.monitor.internal.MonitorServiceImpl;
+import pro.taskana.task.api.TaskService;
+import pro.taskana.task.internal.TaskServiceImpl;
+import pro.taskana.workbasket.api.WorkbasketService;
+import pro.taskana.workbasket.internal.WorkbasketServiceImpl;
+
+@ExtendWith(TaskanaIntegrationTestExtension.class)
+public class TaskanaDependencyInjectionExtensionTest {
+
+  @Nested
+  class TaskanaEngineConfigurationInjectionTest {
+    private final TaskanaEngineConfiguration taskanaEngineConfiguration;
+
+    public TaskanaEngineConfigurationInjectionTest(
+        TaskanaEngineConfiguration taskanaEngineConfiguration) {
+      this.taskanaEngineConfiguration = taskanaEngineConfiguration;
+    }
+
+    @Test
+    void should_InjectTaskanaEngineConfiguration_When_ConstructorContainsParameter() {
+      assertThat(taskanaEngineConfiguration).isNotNull();
+    }
+  }
+
+  @Nested
+  class TaskanaEngineInjectionTest {
+    private final TaskanaEngine taskanaEngine;
+    private final TaskanaEngineImpl taskanaEngineImpl;
+
+    TaskanaEngineInjectionTest(TaskanaEngine taskanaEngine, TaskanaEngineImpl taskanaEngineImpl) {
+      this.taskanaEngine = taskanaEngine;
+      this.taskanaEngineImpl = taskanaEngineImpl;
+    }
+
+    @Test
+    void should_InjectTaskanaEngine_When_ConstructorContainsParameter() {
+      assertThat(taskanaEngine).isNotNull();
+    }
+
+    @Test
+    void should_InjectTaskanaEngineImpl_When_ConstructorContainsParameter() {
+      assertThat(taskanaEngineImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class TaskServiceInjectionTest {
+    private final TaskService taskService;
+    private final TaskServiceImpl taskServiceImpl;
+
+    TaskServiceInjectionTest(TaskService taskService, TaskServiceImpl taskServiceImpl) {
+      this.taskService = taskService;
+      this.taskServiceImpl = taskServiceImpl;
+    }
+
+    @Test
+    void should_InjectTaskService_When_ConstructorContainsParameter() {
+      assertThat(taskService).isNotNull();
+    }
+
+    @Test
+    void should_InjectTaskServiceImpl_When_ConstructorContainsParameter() {
+      assertThat(taskServiceImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class MonitorServiceInjectionTest {
+    private final MonitorService monitorService;
+    private final MonitorServiceImpl monitorServiceImpl;
+
+    MonitorServiceInjectionTest(
+        MonitorService monitorService, MonitorServiceImpl monitorServiceImpl) {
+      this.monitorService = monitorService;
+      this.monitorServiceImpl = monitorServiceImpl;
+    }
+
+    @Test
+    void should_InjectMonitorService_When_ConstructorContainsParameter() {
+      assertThat(monitorService).isNotNull();
+    }
+
+    @Test
+    void should_InjectMonitorServiceImpl_When_ConstructorContainsParameter() {
+      assertThat(monitorServiceImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class WorkbasketServiceInjectionTest {
+    private final WorkbasketService workbasketService;
+    private final WorkbasketServiceImpl workbasketServiceImpl;
+
+    WorkbasketServiceInjectionTest(
+        WorkbasketService workbasketService, WorkbasketServiceImpl workbasketServiceImpl) {
+      this.workbasketService = workbasketService;
+      this.workbasketServiceImpl = workbasketServiceImpl;
+    }
+
+    @Test
+    void should_InjectWorkbasketService_When_ConstructorContainsParameter() {
+      assertThat(workbasketService).isNotNull();
+    }
+
+    @Test
+    void should_InjectWorkbasketServiceImpl_When_ConstructorContainsParameter() {
+      assertThat(workbasketServiceImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class ClassificationServiceInjectionTest {
+    private final ClassificationService classificationService;
+    private final ClassificationServiceImpl classificationServiceImpl;
+
+    ClassificationServiceInjectionTest(
+        ClassificationService classificationService,
+        ClassificationServiceImpl classificationServiceImpl) {
+      this.classificationService = classificationService;
+      this.classificationServiceImpl = classificationServiceImpl;
+    }
+
+    @Test
+    void should_InjectClassificationService_When_ConstructorContainsParameter() {
+      assertThat(classificationService).isNotNull();
+    }
+
+    @Test
+    void should_InjectClassificationServiceImpl_When_ConstructorContainsParameter() {
+      assertThat(classificationServiceImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class JobServiceInjectionTest {
+    private final JobService jobService;
+    private final JobServiceImpl jobServiceImpl;
+
+    JobServiceInjectionTest(JobService jobService, JobServiceImpl jobServiceImpl) {
+      this.jobService = jobService;
+      this.jobServiceImpl = jobServiceImpl;
+    }
+
+    @Test
+    void should_InjectJobService_When_ConstructorContainsParameter() {
+      assertThat(jobService).isNotNull();
+    }
+
+    @Test
+    void should_InjectJobServiceImpl_When_ConstructorContainsParameter() {
+      assertThat(jobServiceImpl).isNotNull();
+    }
+  }
+
+  @Nested
+  class WorkingDaysToDaysConverterInjectionTest {
+    private final WorkingDaysToDaysConverter workingDaysToDaysConverter;
+
+    WorkingDaysToDaysConverterInjectionTest(WorkingDaysToDaysConverter workingDaysToDaysConverter) {
+      this.workingDaysToDaysConverter = workingDaysToDaysConverter;
+    }
+
+    @Test
+    void should_InjectWorkingDaysToDaysConverter_When_ConstructorContainsParameter() {
+      assertThat(workingDaysToDaysConverter).isNotNull();
+    }
+  }
+}

lib/taskana-core/src/test/java/acceptance/TaskanaIntegrationTestExtension.java

@@ -0,0 +1,32 @@
+package acceptance;
+
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.ParameterContext;
+import org.junit.jupiter.api.extension.ParameterResolutionException;
+import org.junit.jupiter.api.extension.ParameterResolver;
+
+import pro.taskana.common.test.config.DataSourceGenerator;
+
+public class TaskanaIntegrationTestExtension implements ParameterResolver {
+
+  private final TaskanaDependencyInjectionExtension dependencyInjectionExtension;
+
+  public TaskanaIntegrationTestExtension() throws Exception {
+    dependencyInjectionExtension =
+        new TaskanaDependencyInjectionExtension(DataSourceGenerator.getDataSource());
+  }
+
+  @Override
+  public boolean supportsParameter(
+      ParameterContext parameterContext, ExtensionContext extensionContext)
+      throws ParameterResolutionException {
+    return dependencyInjectionExtension.supportsParameter(parameterContext, extensionContext);
+  }
+
+  @Override
+  public Object resolveParameter(
+      ParameterContext parameterContext, ExtensionContext extensionContext)
+      throws ParameterResolutionException {
+    return dependencyInjectionExtension.resolveParameter(parameterContext, extensionContext);
+  }
+}

lib/taskana-core/src/test/java/acceptance/builder/ClassificationBuilderTest.java

@@ -4,13 +4,12 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static pro.taskana.classification.internal.ClassificationBuilder.newClassification;
 
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.time.Instant;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DynamicContainer;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
@@ -22,20 +21,17 @@ import pro.taskana.classification.api.ClassificationService;
 import pro.taskana.classification.api.models.Classification;
 import pro.taskana.classification.internal.ClassificationBuilder;
 import pro.taskana.classification.internal.models.ClassificationImpl;
-import pro.taskana.common.api.TaskanaEngine;
 import pro.taskana.common.internal.util.Quadruple;
 import pro.taskana.common.test.security.JaasExtension;
 import pro.taskana.common.test.security.WithAccessId;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
 class ClassificationBuilderTest {
 
-  private static ClassificationService classificationService;
+  private final ClassificationService classificationService;
 
-  @BeforeAll
-  static void setup() throws Exception {
-    TaskanaEngine taskanaEngine = FooBar.getTaskanaEngineForTests();
-    classificationService = taskanaEngine.getClassificationService();
+  public ClassificationBuilderTest(ClassificationService classificationService) {
+    this.classificationService = classificationService;
   }
 
   @WithAccessId(user = "businessadmin")

lib/taskana-core/src/test/java/acceptance/builder/TaskAttachmentBuilderTest.java

@@ -3,17 +3,15 @@ package acceptance.builder;
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 
 import acceptance.DefaultTestEntities;
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.time.Instant;
 import java.util.Map;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.classification.api.ClassificationService;
 import pro.taskana.classification.api.models.ClassificationSummary;
 import pro.taskana.classification.internal.ClassificationBuilder;
-import pro.taskana.common.api.TaskanaEngine;
 import pro.taskana.common.test.security.JaasExtension;
 import pro.taskana.task.api.TaskService;
 import pro.taskana.task.api.models.Attachment;
@@ -21,17 +19,15 @@ import pro.taskana.task.api.models.ObjectReference;
 import pro.taskana.task.internal.TaskAttachmentBuilder;
 import pro.taskana.task.internal.models.AttachmentImpl;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
 class TaskAttachmentBuilderTest {
 
-  private static ClassificationService classificationService;
-  private static TaskService taskService;
+  private final ClassificationService classificationService;
+  private final TaskService taskService;
 
-  @BeforeAll
-  static void setup() throws Exception {
-    TaskanaEngine taskanaEngine = FooBar.getTaskanaEngineForTests();
-    classificationService = taskanaEngine.getClassificationService();
-    taskService = taskanaEngine.getTaskService();
+  TaskAttachmentBuilderTest(ClassificationService classificationService, TaskService taskService) {
+    this.classificationService = classificationService;
+    this.taskService = taskService;
   }
 
   @Test

lib/taskana-core/src/test/java/acceptance/builder/TaskBuilderTest.java

@@ -9,7 +9,7 @@ import static pro.taskana.common.internal.util.CheckedSupplier.wrap;
 import static pro.taskana.task.internal.builder.TaskBuilder.newTask;
 import static pro.taskana.workbasket.internal.WorkbasketAccessItemBuilder.newWorkbasketAccessItem;
 
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.time.Instant;
 import java.util.List;
 import java.util.Map;
@@ -21,6 +21,8 @@ import org.junit.jupiter.api.DynamicContainer;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.classification.api.ClassificationService;
@@ -42,21 +44,24 @@ import pro.taskana.workbasket.api.WorkbasketPermission;
 import pro.taskana.workbasket.api.WorkbasketService;
 import pro.taskana.workbasket.api.models.WorkbasketSummary;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
+@TestInstance(Lifecycle.PER_CLASS)
 class TaskBuilderTest {
-  private static TaskService taskService;
-  private static WorkbasketSummary workbasketSummary;
-  private static ClassificationSummary classificationSummary;
-  private static TaskanaEngine taskanaEngine;
+  private final TaskanaEngine taskanaEngine;
+  private final TaskService taskService;
+
+  private WorkbasketSummary workbasketSummary;
+  private ClassificationSummary classificationSummary;
+
+  TaskBuilderTest(TaskanaEngine taskanaEngine, TaskService taskService) {
+    this.taskanaEngine = taskanaEngine;
+    this.taskService = taskService;
+  }
 
   @WithAccessId(user = "businessadmin")
   @BeforeAll
-  static void setup() throws Exception {
-    taskanaEngine = FooBar.getTaskanaEngineForTests();
-    taskService = taskanaEngine.getTaskService();
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    ClassificationService classificationService = taskanaEngine.getClassificationService();
-
+  void setup(WorkbasketService workbasketService, ClassificationService classificationService)
+      throws Exception {
     workbasketSummary =
         defaultTestWorkbasket()
             .owner("user-1-1")

lib/taskana-core/src/test/java/acceptance/builder/TaskCommentBuilderTest.java

@@ -9,7 +9,7 @@ import static pro.taskana.common.internal.util.CheckedSupplier.wrap;
 import static pro.taskana.task.internal.TaskCommentBuilder.newTaskComment;
 import static pro.taskana.workbasket.internal.WorkbasketAccessItemBuilder.newWorkbasketAccessItem;
 
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.time.Instant;
 import java.util.List;
 import java.util.function.BiFunction;
@@ -20,6 +20,8 @@ import org.junit.jupiter.api.DynamicContainer;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestFactory;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.api.TestInstance.Lifecycle;
 import org.junit.jupiter.api.extension.ExtendWith;
 
 import pro.taskana.classification.api.ClassificationService;
@@ -39,21 +41,24 @@ import pro.taskana.workbasket.api.WorkbasketPermission;
 import pro.taskana.workbasket.api.WorkbasketService;
 import pro.taskana.workbasket.api.models.Workbasket;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
+@TestInstance(Lifecycle.PER_CLASS)
 class TaskCommentBuilderTest {
 
-  private static TaskService taskService;
-  private static Task task;
-  private static TaskanaEngine taskanaEngine;
+  private final TaskService taskService;
+  private final TaskanaEngine taskanaEngine;
+
+  private Task task;
+
+  TaskCommentBuilderTest(TaskService taskService, TaskanaEngine taskanaEngine) {
+    this.taskService = taskService;
+    this.taskanaEngine = taskanaEngine;
+  }
 
   @WithAccessId(user = "businessadmin")
   @BeforeAll
-  static void setup() throws Exception {
-    taskanaEngine = FooBar.getTaskanaEngineForTests();
-    taskService = taskanaEngine.getTaskService();
-    WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
-    ClassificationService classificationService = taskanaEngine.getClassificationService();
-
+  void setup(WorkbasketService workbasketService, ClassificationService classificationService)
+      throws Exception {
     ObjectReference objectReference = defaultTestObjectReference().build();
     Workbasket workbasket =
         defaultTestWorkbasket().owner("user-1-1").key("key0_E").buildAndStore(workbasketService);

lib/taskana-core/src/test/java/acceptance/builder/WorkbasketAccessItemBuilderTest.java

@@ -6,9 +6,8 @@ import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode;
 import static pro.taskana.common.internal.util.CheckedSupplier.wrap;
 import static pro.taskana.workbasket.internal.WorkbasketAccessItemBuilder.newWorkbasketAccessItem;
 
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.util.List;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 
@@ -22,17 +21,16 @@ import pro.taskana.workbasket.api.models.WorkbasketAccessItem;
 import pro.taskana.workbasket.internal.WorkbasketAccessItemBuilder;
 import pro.taskana.workbasket.internal.models.WorkbasketAccessItemImpl;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
 class WorkbasketAccessItemBuilderTest {
 
-  private static WorkbasketService workbasketService;
-  private static TaskanaEngine taskanaEngine;
+  private final WorkbasketService workbasketService;
+  private final TaskanaEngine taskanaEngine;
 
-  @BeforeAll
-  @WithAccessId(user = "businessadmin")
-  static void setup() throws Exception {
-    taskanaEngine = FooBar.getTaskanaEngineForTests();
-    workbasketService = taskanaEngine.getWorkbasketService();
+  WorkbasketAccessItemBuilderTest(
+      WorkbasketService workbasketService, TaskanaEngine taskanaEngine) {
+    this.workbasketService = workbasketService;
+    this.taskanaEngine = taskanaEngine;
   }
 
   @WithAccessId(user = "businessadmin")

lib/taskana-core/src/test/java/acceptance/builder/WorkbasketBuilderTest.java

@@ -5,13 +5,12 @@ import static org.assertj.core.api.Assertions.assertThatCode;
 import static pro.taskana.common.internal.util.CheckedSupplier.wrap;
 import static pro.taskana.workbasket.internal.WorkbasketBuilder.newWorkbasket;
 
-import acceptance.FooBar;
+import acceptance.TaskanaIntegrationTestExtension;
 import java.time.Instant;
 import java.util.List;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Stream;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DynamicContainer;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.Test;
@@ -29,16 +28,15 @@ import pro.taskana.workbasket.api.models.Workbasket;
 import pro.taskana.workbasket.internal.WorkbasketBuilder;
 import pro.taskana.workbasket.internal.models.WorkbasketImpl;
 
-@ExtendWith(JaasExtension.class)
+@ExtendWith({JaasExtension.class, TaskanaIntegrationTestExtension.class})
 class WorkbasketBuilderTest {
 
-  private static WorkbasketService workbasketService;
-  private static TaskanaEngine taskanaEngine;
+  private final WorkbasketService workbasketService;
+  private final TaskanaEngine taskanaEngine;
 
-  @BeforeAll
-  static void setup() throws Exception {
-    taskanaEngine = FooBar.getTaskanaEngineForTests();
-    workbasketService = taskanaEngine.getWorkbasketService();
+  WorkbasketBuilderTest(WorkbasketService workbasketService, TaskanaEngine taskanaEngine) {
+    this.workbasketService = workbasketService;
+    this.taskanaEngine = taskanaEngine;
   }
 
   @WithAccessId(user = "businessadmin")