Add tenant test, add some docs, activate ITests again

Author: zambrovski

.github/workflows/master.yml

@@ -34,7 +34,7 @@ jobs:
 
       # Build
       - name: Build with Maven
-        run: ./mvnw clean verify -U -B -T4
+        run: ./mvnw clean verify -U -B -T4 -ntp
 
       # Get GPG private key into GPG
       - name: Import GPG Owner Trust

docs/process-engine-worker.md

@@ -9,6 +9,7 @@ API and allows to build universal workers.
 First of all add the Process Engine Worker dependency to your projects classpath. In Maven add the following to your `pom.xml`:
 
 ```xml
+
 <dependency>
   <groupId>dev.bpm-crafters.process-engine-worker</groupId>
   <artifactId>process-engine-worker-spring-boot-starter</artifactId>
@@ -19,6 +20,7 @@ First of all add the Process Engine Worker dependency to your projects classpath
 Now create a simple Spring component and annotate a method with a special annotation `@ProcessEngineWorker`:
 
 ```java
+
 @Component
 @RequiredArgsConstructor
 public class MySmartWorker {
@@ -31,39 +33,40 @@ public class MySmartWorker {
   ) {
     // execute some business code
     var fetched = fetchGoodsInPort.fetchGoods(order);
-    
+
     return Map.of("shipped", fetched);
   }
 }
 ```
 
 The `@ProcessEngineWorker` annotation supports the following properties:
 
-| Property       | Type       | Default    | Description                                                                                                                                                                                                                                                                                                                                            |
-|----------------|------------|------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `topic`        | `String`   | `""`       | Topic name to subscribe this worker for. Alias for `value`.                                                                                                                                                                                                                                                                                            |
-| `autoComplete` | `boolean`  | `true`     | Flag indicating if the task should be automatically completed after the worker execution. If the return type is `Map<String, Any>`, it will overrule this setting and auto-complete with the returned payload.                                                                                                                                       |
-| `completion`   | `enum`     | `DEFAULT`  | Configures when the worker completes a task if `autoComplete` is active. Possible values are `DEFAULT`, `BEFORE_COMMIT`, and `AFTER_COMMIT`. Has no effect if the worker is not transactional.                                                                                                                                                         |
-| `lockDuration` | `long`     | `-1`       | Optional lock duration in milliseconds for this worker. If set to `-1` (default), the global configuration of the process engine adapter will be used. (Available since `0.8.0`)                                                                                                                                                                            |
+| Property       | Type      | Default     | Description                                                                                                                                                                                                    |
+|----------------|-----------|-------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `topic`        | `String`  | `"__unset"` | Topic name to subscribe this worker for. Alias for `value`.                                                                                                                                                    |
+| `autoComplete` | `boolean` | `true`      | Flag indicating if the task should be automatically completed after the worker execution. If the return type is `Map<String, Any>`, it will overrule this setting and auto-complete with the returned payload. |
+| `completion`   | `enum`    | `DEFAULT`   | Configures when the worker completes a task if `autoComplete` is active. Possible values are `DEFAULT`, `BEFORE_COMMIT`, and `AFTER_COMMIT`. Has no effect if the worker is not transactional.                 |
+| `lockDuration` | `long`    | `-1`        | Optional lock duration in milliseconds for this worker. If set to `-1` (default), the global configuration of the process engine adapter will be used. (Available since `0.8.0`)                               |
+| `tenantId`     | `String`  | `""`        | Optional tenant id to be used for current worker during the registration. Any non-blank value will be considered. If the value is empty, the value from the property will be used.                             |
 
 ## Method parameter resolution
 
 Parameter resolution of the method annotated with `ProcessEngineWorker` is based on a set of strategies
 registered by the `ParameterResolver` bean. Currently, the following parameters are resolved:
 
-| Type                                   | Purpose                                                                   |
-|----------------------------------------|---------------------------------------------------------------------------|
-| TaskInformation                        | Helper abstracting all information about the external task.               |
-| ExternTaskCompletionApi                | API for completing the external task manually                             |
-| VariableConverter                      | Special utility to read the process variable map and deliver typed value  | 
-| Map<String, Object>                    | Payload object containing all variables.                                  |
-| Type annotated with @Variable("name")  | Marker for a process variable.                                            |
+| Type                                  | Purpose                                                                  |
+|---------------------------------------|--------------------------------------------------------------------------|
+| TaskInformation                       | Helper abstracting all information about the external task.              |
+| ExternTaskCompletionApi               | API for completing the external task manually                            |
+| VariableConverter                     | Special utility to read the process variable map and deliver typed value | 
+| Map<String, Object>                   | Payload object containing all variables.                                 |
+| Type annotated with @Variable("name") | Marker for a process variable.                                           |
 
 Usually, the requested variable is mandatory and the parameter resolver reports an error, if the requested variable is not
 available in the process payload. If you want to inject the variable only if it exists in the payload you have two options.
 Either you set the parameter `@Variable(name = "...", mandatory = false)` or you use `Optional<T>` instead of `T` as a variable
 type. If you are using Kotlin and don't like `Optional`, make sure to declare variable type as nullable (`T?` instead of `T`) and
-set the mandatory flag to `false`. 
+set the mandatory flag to `false`.
 
 ## Method return type
 
@@ -95,6 +98,7 @@ dev:
       worker:
         registerProcessWorkers: true # Enable or disable automatic worker registration
         completeTasksBeforeCommit: false # Determines whether tasks are completed before transaction commit
+        tenantId: my-tenant # Specify the tenant ID for all workers, can be overridden by the value in the `@ProcessEngineWorker` annotation
 ```
 
 

itest/spring-boot-starter-integration-test/pom.xml

@@ -50,6 +50,7 @@
             <phase>integration-test</phase>
             <goals>
               <goal>integration-test</goal>
+              <goal>verify</goal>
             </goals>
           </execution>
         </executions>

itest/spring-boot-starter-integration-test/src/test/kotlin/dev/bpmcrafters/processengine/worker/fixture/TestApplication.kt

@@ -4,15 +4,17 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.datatype.jdk8.Jdk8Module
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import dev.bpmcrafters.processengine.worker.idempotency.TaskLogEntry
+import dev.bpmcrafters.processengine.worker.idempotency.TaskLogEntryRepository
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.autoconfigure.domain.EntityScan
 import org.springframework.context.annotation.Bean
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories
 import java.text.SimpleDateFormat
 
 @SpringBootApplication
-@EntityScan(basePackageClasses = [MyEntity::class])
-@EnableJpaRepositories(basePackageClasses = [MyEntityRepository::class])
+@EntityScan(basePackageClasses = [MyEntity::class, TaskLogEntry::class])
+@EnableJpaRepositories(basePackageClasses = [MyEntityRepository::class, TaskLogEntryRepository::class])
 class TestApplication {
 
   @Bean

spring-boot-starter/src/main/kotlin/dev/bpmcrafters/processengine/worker/ProcessEngineWorker.kt

@@ -42,23 +42,19 @@ annotation class ProcessEngineWorker(
   /**
    * Tenant ID to subscribe this worker for. Defaults to "__unset" representing no tenant.
    */
-  val tenantId: String = DEFAULT_UNSET_TENANT_ID,
+  val tenantId: String = "",
 ) {
   companion object {
     /**
      * Null value for the topic.
      */
     const val DEFAULT_UNSET_TOPIC = "__unset"
 
-    /**
-     * Null value for the tenant.
-     */
-    const val DEFAULT_UNSET_TENANT_ID = "__unset"
-
     /**
      * Sentinel value indicating lock duration is not specified.
      */
     const val DEFAULT_UNSET_LOCK_DURATION = -1L
+
   }
 
   /**

spring-boot-starter/src/main/kotlin/dev/bpmcrafters/processengine/worker/registrar/ReflectionUtils.kt

@@ -152,14 +152,14 @@ fun Method.getTopic(): String {
  * Returns the auto-completion flag from annotation.
  */
 fun Method.getAutoComplete(): Boolean {
-  return this.getAnnotation(ProcessEngineWorker::class.java).autoComplete
+  return AnnotationUtils.findAnnotation(this, ProcessEngineWorker::class.java)!!.autoComplete
 }
 
 /**
  * Returns the auto-completion flag from annotation.
  */
 fun Method.getCompletion(): Completion {
-  return this.getAnnotation(ProcessEngineWorker::class.java).completion
+  return AnnotationUtils.findAnnotation(this, ProcessEngineWorker::class.java)!!.completion
 }
 
 /**
@@ -168,7 +168,7 @@ fun Method.getCompletion(): Completion {
  * @since 0.8.0
  */
 fun Method.getLockDuration(): Long? {
-  val lockDuration = this.getAnnotation(ProcessEngineWorker::class.java).lockDuration
+  val lockDuration = AnnotationUtils.findAnnotation(this, ProcessEngineWorker::class.java)!!.lockDuration
   return if (lockDuration == ProcessEngineWorker.DEFAULT_UNSET_LOCK_DURATION) {
     null
   } else {
@@ -182,11 +182,9 @@ fun Method.getLockDuration(): Long? {
  * @since 0.8.4
  */
 fun Method.getTenantId(): String? {
-  val tenantId = this.getAnnotation(ProcessEngineWorker::class.java).tenantId
-  return if (tenantId == ProcessEngineWorker.DEFAULT_UNSET_TENANT_ID || tenantId.isBlank()) {
+  val tenantId = AnnotationUtils.findAnnotation(this, ProcessEngineWorker::class.java)!!.tenantId
+  return tenantId.ifBlank {
     null
-  } else {
-    tenantId
   }
 }
 

spring-boot-starter/src/test/kotlin/dev/bpmcrafters/processengine/worker/registrar/ProcessEngineStarterRegistrarTenantTest.kt

@@ -0,0 +1,117 @@
+package dev.bpmcrafters.processengine.worker.registrar
+
+import dev.bpmcrafters.processengine.worker.ProcessEngineWorker
+import dev.bpmcrafters.processengine.worker.configuration.ProcessEngineWorkerProperties
+import dev.bpmcrafters.processengine.worker.idempotency.IdempotencyRegistry
+import dev.bpmcrafters.processengineapi.CommonRestrictions
+import dev.bpmcrafters.processengineapi.task.ServiceTaskCompletionApi
+import dev.bpmcrafters.processengineapi.task.SubscribeForTaskCmd
+import dev.bpmcrafters.processengineapi.task.TaskSubscriptionApi
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+import org.mockito.kotlin.*
+import org.springframework.transaction.support.TransactionTemplate
+import java.util.concurrent.CompletableFuture
+
+internal class ProcessEngineStarterRegistrarTenantTest {
+
+  private val properties = ProcessEngineWorkerProperties()
+  private val taskSubscriptionApi = mock<TaskSubscriptionApi>()
+  private val taskCompletionApi = mock<ServiceTaskCompletionApi>()
+  private val variableConverter = mock<VariableConverter>()
+  private val parameterResolver = mock<ParameterResolver>()
+  private val resultResolver = mock<ResultResolver>()
+  private val transactionalTemplate = mock<TransactionTemplate>()
+  private val metrics = mock<ProcessEngineWorkerMetrics>()
+  private val idempotencyRegistry = mock<IdempotencyRegistry>()
+
+  private val testSubject = ProcessEngineStarterRegistrar(
+    properties,
+    taskSubscriptionApi,
+    taskCompletionApi,
+    variableConverter,
+    parameterResolver,
+    resultResolver,
+    transactionalTemplate,
+    metrics,
+    idempotencyRegistry
+  )
+
+  @Test
+  fun `should use tenantId from annotation`() {
+    class TenantWorker {
+      @ProcessEngineWorker(topic = "test", tenantId = "tenant-from-annotation")
+      fun work() {}
+    }
+
+    val bean = TenantWorker()
+    whenever(taskSubscriptionApi.subscribeForTask(any())).thenReturn(CompletableFuture.completedFuture(mock()))
+
+    testSubject.postProcessAfterInitialization(bean, "tenantWorker")
+
+    val captor = argumentCaptor<SubscribeForTaskCmd>()
+    verify(taskSubscriptionApi).subscribeForTask(captor.capture())
+
+    assertThat(captor.firstValue.restrictions[CommonRestrictions.TENANT_ID]).isEqualTo("tenant-from-annotation")
+  }
+
+  @Test
+  fun `should use tenantId from properties if not specified on annotation`() {
+    properties.tenantId = "tenant-from-properties"
+
+    class NoTenantWorker {
+      @ProcessEngineWorker(topic = "test")
+      fun work() {}
+    }
+
+    val bean = NoTenantWorker()
+    whenever(taskSubscriptionApi.subscribeForTask(any())).thenReturn(CompletableFuture.completedFuture(mock()))
+
+    testSubject.postProcessAfterInitialization(bean, "noTenantWorker")
+
+    val captor = argumentCaptor<SubscribeForTaskCmd>()
+    verify(taskSubscriptionApi).subscribeForTask(captor.capture())
+
+    assertThat(captor.firstValue.restrictions[CommonRestrictions.TENANT_ID]).isEqualTo("tenant-from-properties")
+  }
+
+  @Test
+  fun `annotation tenantId should overrule property tenantId`() {
+    properties.tenantId = "tenant-from-properties"
+
+    class OverruleWorker {
+      @ProcessEngineWorker(topic = "test", tenantId = "tenant-from-annotation")
+      fun work() {}
+    }
+
+    val bean = OverruleWorker()
+    whenever(taskSubscriptionApi.subscribeForTask(any())).thenReturn(CompletableFuture.completedFuture(mock()))
+
+    testSubject.postProcessAfterInitialization(bean, "overruleWorker")
+
+    val captor = argumentCaptor<SubscribeForTaskCmd>()
+    verify(taskSubscriptionApi).subscribeForTask(captor.capture())
+
+    assertThat(captor.firstValue.restrictions[CommonRestrictions.TENANT_ID]).isEqualTo("tenant-from-annotation")
+  }
+
+  @Test
+  fun `should not have tenantId restriction if neither is specified`() {
+    properties.tenantId = null
+
+    class NoTenantAtAllWorker {
+      @ProcessEngineWorker(topic = "test")
+      fun work() {}
+    }
+
+    val bean = NoTenantAtAllWorker()
+    whenever(taskSubscriptionApi.subscribeForTask(any())).thenReturn(CompletableFuture.completedFuture(mock()))
+
+    testSubject.postProcessAfterInitialization(bean, "noTenantAtAllWorker")
+
+    val captor = argumentCaptor<SubscribeForTaskCmd>()
+    verify(taskSubscriptionApi).subscribeForTask(captor.capture())
+
+    assertThat(captor.firstValue.restrictions).doesNotContainKey(CommonRestrictions.TENANT_ID)
+  }
+}