Add jgiven support

engine-adapter/adapter-testing/pom.xml

@@ -15,7 +15,6 @@
 
   <properties>
     <h2.version>2.2.224</h2.version>
-    <camunda-platform-7-mockito.version>7.21.0</camunda-platform-7-mockito.version>
     <mockk.version>1.13.12</mockk.version>
     <jgiven.version>1.3.1</jgiven.version>
   </properties>

engine-adapter/camunda-platform-7-embedded-core/pom.xml

@@ -46,14 +46,38 @@
       <scope>provided</scope>
     </dependency>
 
+    <!-- For JGiven Testing -->
+    <dependency>
+      <groupId>com.tngtech.jgiven</groupId>
+      <artifactId>jgiven-core</artifactId>
+      <version>1.3.1</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.awaitility</groupId>
+      <artifactId>awaitility-kotlin</artifactId>
+      <version>4.2.2</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.camunda.bpm</groupId>
+      <artifactId>camunda-bpm-assert</artifactId>
+      <version>${camunda.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
     <!-- Testing -->
     <dependency>
       <groupId>dev.bpm-crafters.process-engine-api</groupId>
       <artifactId>process-engine-api-adapter-testing</artifactId>
       <version>${project.version}</version>
       <scope>test</scope>
     </dependency>
-
     <dependency>
       <groupId>com.h2database</groupId>
       <artifactId>h2</artifactId>
@@ -66,12 +90,6 @@
       <version>${camunda.version}</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.camunda.bpm</groupId>
-      <artifactId>camunda-bpm-assert</artifactId>
-      <version>${camunda.version}</version>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>org.camunda.community.mockito</groupId>
       <artifactId>camunda-platform-7-mockito</artifactId>

engine-adapter/camunda-platform-7-embedded-core/src/main/kotlin/dev/bpmcrafters/processengineapi/adapter/c7/embedded/testing/AbstractC7EmbeddedStage.kt

@@ -0,0 +1,216 @@
+package dev.bpmcrafters.processengineapi.adapter.c7.embedded.testing
+
+import com.tngtech.jgiven.Stage
+import com.tngtech.jgiven.annotation.ProvidedScenarioState
+import com.tngtech.jgiven.annotation.ScenarioState
+import dev.bpmcrafters.processengineapi.CommonRestrictions
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.deploy.DeploymentApiImpl
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.process.StartProcessApiImpl
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.completion.C7ServiceTaskCompletionApiImpl
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.completion.C7UserTaskCompletionApiImpl
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.completion.LinearMemoryFailureRetrySupplier
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.delivery.pull.EmbeddedPullServiceTaskDelivery
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.delivery.pull.EmbeddedPullUserTaskDelivery
+import dev.bpmcrafters.processengineapi.adapter.c7.embedded.task.subscription.C7TaskSubscriptionApiImpl
+import dev.bpmcrafters.processengineapi.adapter.commons.task.InMemSubscriptionRepository
+import dev.bpmcrafters.processengineapi.adapter.commons.task.UserTaskSupport
+import dev.bpmcrafters.processengineapi.deploy.DeployBundleCommand
+import dev.bpmcrafters.processengineapi.deploy.DeploymentApi
+import dev.bpmcrafters.processengineapi.deploy.NamedResource.Companion.fromClasspath
+import dev.bpmcrafters.processengineapi.process.StartProcessApi
+import dev.bpmcrafters.processengineapi.task.*
+import org.assertj.core.api.Assertions
+import org.awaitility.Awaitility
+import org.camunda.bpm.engine.ProcessEngineServices
+import org.camunda.bpm.engine.runtime.ProcessInstance
+import org.camunda.bpm.engine.test.assertions.bpmn.BpmnAwareTests
+import org.camunda.bpm.engine.variable.VariableMap
+import java.util.*
+import java.util.concurrent.Executors
+import java.util.function.Supplier
+import kotlin.collections.set
+
+abstract class AbstractC7EmbeddedStage<SUBTYPE : AbstractC7EmbeddedStage<SUBTYPE>> : Stage<SUBTYPE>() {
+
+  @ProvidedScenarioState
+  private lateinit var restrictions: Map<String, String>
+
+  @ProvidedScenarioState(resolution = ScenarioState.Resolution.NAME)
+  protected lateinit var workerId: String
+
+  @ProvidedScenarioState
+  protected lateinit var userTaskSupport: UserTaskSupport
+
+  @ProvidedScenarioState
+  protected lateinit var startProcessApi: StartProcessApi
+
+  @ProvidedScenarioState
+  protected lateinit var userTaskCompletionApi: UserTaskCompletionApi
+
+  @ProvidedScenarioState
+  protected lateinit var serviceTaskCompletionApi: ServiceTaskCompletionApi
+
+  @ProvidedScenarioState
+  protected lateinit var taskSubscriptionApi: TaskSubscriptionApi
+
+  @ProvidedScenarioState
+  protected lateinit var deploymentApi: DeploymentApi
+
+  @ProvidedScenarioState
+  protected lateinit var processEngineServices: ProcessEngineServices
+
+  @ProvidedScenarioState
+  lateinit var embeddedPullUserTaskDelivery: EmbeddedPullUserTaskDelivery
+
+  @ProvidedScenarioState
+  private lateinit var embeddedPullServiceTaskDelivery: EmbeddedPullServiceTaskDelivery
+
+  @ProvidedScenarioState
+  protected lateinit var processInstanceSupplier: Supplier<ProcessInstance>
+
+  @ProvidedScenarioState(resolution = ScenarioState.Resolution.NAME)
+  private lateinit var topicToExternalTaskId: MutableMap<String, String>
+
+  @ProvidedScenarioState
+  protected lateinit var taskInformation: TaskInformation
+
+
+  open fun initializeEngine(
+    processEngineServices: ProcessEngineServices, restrictions: Map<String, String>
+  ): SUBTYPE {
+    this.topicToExternalTaskId = HashMap()
+    this.restrictions = restrictions
+    this.processEngineServices = processEngineServices
+    this.workerId = self().javaClass.simpleName
+
+    val subscriptionRepository = InMemSubscriptionRepository()
+
+    startProcessApi = StartProcessApiImpl(processEngineServices.runtimeService)
+    deploymentApi = DeploymentApiImpl(processEngineServices.repositoryService)
+    userTaskCompletionApi = C7UserTaskCompletionApiImpl(processEngineServices.taskService, subscriptionRepository)
+    serviceTaskCompletionApi = C7ServiceTaskCompletionApiImpl(
+      workerId, processEngineServices.externalTaskService, subscriptionRepository, LinearMemoryFailureRetrySupplier(3, 3L)
+    )
+    embeddedPullUserTaskDelivery = EmbeddedPullUserTaskDelivery(
+      processEngineServices.taskService, processEngineServices.repositoryService, subscriptionRepository, Executors.newFixedThreadPool(1)
+    )
+
+    embeddedPullServiceTaskDelivery = EmbeddedPullServiceTaskDelivery(
+      processEngineServices.externalTaskService, workerId, subscriptionRepository, Int.MAX_VALUE, 1000, 1000, 1, Executors.newFixedThreadPool(1)
+    )
+
+    taskSubscriptionApi = C7TaskSubscriptionApiImpl(
+      subscriptionRepository
+    )
+
+    this.userTaskSupport = UserTaskSupport()
+    userTaskSupport.subscribe(
+      taskSubscriptionApi, restrictions, null, null
+    )
+
+    initialize()
+
+    // activate delivery
+    embeddedPullUserTaskDelivery.refresh()
+    embeddedPullServiceTaskDelivery.refresh()
+    return self()
+  }
+
+
+  /**
+   * Called after Process Engine and API are initialized.
+   */
+  open fun initialize() {
+  }
+
+  open fun process_continues(elementId: String): SUBTYPE {
+    Awaitility.await().untilAsserted {
+      val job = BpmnAwareTests.job(elementId, processInstanceSupplier.get())
+      Assertions.assertThat(job).isNotNull()
+      BpmnAwareTests.execute(job)
+    }
+    return self()
+  }
+
+  open fun process_waits_in(taskDescriptionKey: String): SUBTYPE {
+    // try to get the task
+    Awaitility.await().untilAsserted {
+      val taskIdOption = findTaskByActivityId(taskDescriptionKey)
+      Assertions.assertThat(taskIdOption).describedAs("Process is not waiting in user task $taskDescriptionKey", taskDescriptionKey).isNotEmpty()
+      taskIdOption.ifPresent { taskId: String? ->
+        this.taskInformation = userTaskSupport.getTaskInformation(taskId!!)
+      }
+    }
+    return self()
+  }
+
+  open fun external_task_is_completed(topicName: String, variables: VariableMap): SUBTYPE {
+    Objects.requireNonNull(
+      topicToExternalTaskId[topicName], "No active external service task found, consider to assert using external_task_exists"
+    )
+    serviceTaskCompletionApi.completeTask(CompleteTaskCmd(
+      topicToExternalTaskId.getValue(topicName)
+    ) { variables }).get()
+    return self()
+  }
+
+  open fun external_task_exists(topicName: String): SUBTYPE {
+    taskSubscriptionApi.subscribeForTask(
+      SubscribeForTaskCmd(restrictions,
+        TaskType.EXTERNAL,
+        topicName,
+        null,
+        { ti, _ -> topicToExternalTaskId[topicName] = ti.taskId },
+        { _ -> topicToExternalTaskId.remove(topicName) })
+    )
+    Awaitility.await().untilAsserted {
+      embeddedPullServiceTaskDelivery.refresh()
+      Assertions.assertThat(topicToExternalTaskId.containsKey(topicName)).isTrue()
+    }
+    return self()
+  }
+
+  open fun task_is_assigned_to_user(assignee: String): SUBTYPE {
+    Assertions.assertThat(task().meta["assignee"]).isEqualTo(assignee)
+    return self()
+  }
+
+  open fun process_is_finished(): SUBTYPE {
+    BpmnAwareTests.assertThat(processInstanceSupplier.get()).isEnded()
+    return self()
+  }
+
+  open fun process_has_passed(vararg elementIds: String?): SUBTYPE {
+    BpmnAwareTests.assertThat(processInstanceSupplier.get()).hasPassed(*elementIds)
+    return self()
+  }
+
+  open fun process_is_deployed(resource: String): SUBTYPE {
+    deploymentApi.deploy(
+      DeployBundleCommand(
+        listOf(fromClasspath(resource)), null
+      )
+    ).get()
+    return self()
+  }
+
+  open fun process_stopped(): SUBTYPE {
+    processEngineServices.runtimeService.deleteProcessInstance(processInstanceSupplier.get().processInstanceId, "Stopped", false, true)
+    return self()
+  }
+
+
+  open fun task(): TaskInformation {
+    return Objects.requireNonNull(taskInformation, "No task found, consider to assert using process_waits_in")
+  }
+
+
+  private fun findTaskByActivityId(taskDescriptionKey: String): Optional<String> {
+    embeddedPullUserTaskDelivery.refresh()
+    return Optional.ofNullable(
+      userTaskSupport
+        .getAllTasks()
+        .find { ti: TaskInformation -> ti.meta[CommonRestrictions.TASK_DEFINITION_KEY] == taskDescriptionKey }?.taskId
+    )
+  }
+}

engine-adapter/camunda-platform-8-core/pom.xml

@@ -14,6 +14,7 @@
   <properties>
     <zeebe-client-java.version>8.6.0</zeebe-client-java.version>
     <camunda-tasklist-client-java.version>8.5.3.6</camunda-tasklist-client-java.version>
+    <spring-zeebe.version>8.5.3</spring-zeebe.version>
   </properties>
 
   <dependencies>
@@ -56,6 +57,38 @@
         </exclusion>
       </exclusions>
     </dependency>
+
+    <!-- For JGiven Testing -->
+    <dependency>
+      <groupId>com.tngtech.jgiven</groupId>
+      <artifactId>jgiven-core</artifactId>
+      <version>1.3.1</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.awaitility</groupId>
+      <artifactId>awaitility-kotlin</artifactId>
+      <version>4.2.2</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.camunda</groupId>
+      <artifactId>zeebe-process-test-assertions</artifactId>
+      <version>${spring-zeebe.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.camunda</groupId>
+      <artifactId>zeebe-process-test-extension-testcontainer</artifactId>
+      <version>${spring-zeebe.version}</version>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <scope>provided</scope>
+    </dependency>
+
   </dependencies>
 
 </project>