Change uniqueId to jsonPointer; replace tests with mock

Signed-off-by: Ricardo Zanini <ricardozanini@gmail.com>

Author: ricardozanini

experimental/fluent/func/pom.xml

@@ -39,6 +39,12 @@
             <artifactId>junit-jupiter-api</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>${version.org.mockito}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 </project>

experimental/fluent/func/src/main/java/io/serverlessworkflow/fluent/func/dsl/FuncDSL.java

@@ -27,6 +27,7 @@
 import io.serverlessworkflow.fluent.func.configurers.FuncTaskConfigurer;
 import io.serverlessworkflow.fluent.func.configurers.SwitchCaseConfigurer;
 import io.serverlessworkflow.fluent.func.dsl.internal.CommonFuncOps;
+import io.serverlessworkflow.impl.TaskContextData;
 import io.serverlessworkflow.impl.WorkflowContextData;
 import java.util.Collection;
 import java.util.List;
@@ -383,10 +384,18 @@ public static <T, R> FuncCallStep<T, R> withInstanceId(
     return new FuncCallStep<>(name, jcf, in);
   }
 
+  /**
+   * Builds a composition of the current workflow instance id and the definition of the task
+   * position as a JSON pointer.
+   */
+  static String defaultUniqueId(WorkflowContextData wctx, TaskContextData tctx) {
+    return String.format("%s-%s", wctx.instanceData().id(), tctx.position().jsonPointer());
+  }
+
   /**
    * Build a call step for functions that expect a composition with the workflow instance id and the
-   * task name as the first parameter. The instance ID is extracted from the runtime context, the
-   * task name from the definition.
+   * task position as the first parameter. The instance ID is extracted from the runtime context,
+   * the task position from the definition.
    *
    * <p>Signature expected: {@code (uniqueId, payload) -> result}
    *
@@ -399,8 +408,7 @@ public static <T, R> FuncCallStep<T, R> withInstanceId(
   public static <T, R> FuncCallStep<T, R> withUniqueId(
       String name, UniqueIdBiFunction<T, R> fn, Class<T> in) {
     JavaFilterFunction<T, R> jff =
-        (payload, wctx, tctx) ->
-            fn.apply(String.format("%s-%s", wctx.instanceData().id(), tctx.taskName()), payload);
+        (payload, wctx, tctx) -> fn.apply(defaultUniqueId(wctx, tctx), payload);
     return new FuncCallStep<>(name, jff, in);
   }
 
@@ -735,7 +743,7 @@ public static <T> FuncTaskConfigurer switchWhenOrElse(
    *   switchWhenOrElse(".approved == true", "sendEmail", FlowDirectiveEnum.END)
    * </pre>
    *
-   * The JQ expression is evaluated against the task input at runtime.
+   * <p>The JQ expression is evaluated against the task input at runtime.
    */
   public static FuncTaskConfigurer switchWhenOrElse(
       String jqExpression, String thenTask, FlowDirectiveEnum otherwise) {
@@ -756,7 +764,7 @@ public static FuncTaskConfigurer switchWhenOrElse(
    *   switchWhenOrElse(".score >= 80", "pass", "fail")
    * </pre>
    *
-   * The JQ expression is evaluated against the task input at runtime.
+   * <p>The JQ expression is evaluated against the task input at runtime.
    */
   public static FuncTaskConfigurer switchWhenOrElse(
       String jqExpression, String thenTask, String otherwiseTask) {

experimental/fluent/func/src/test/java/io/serverlessworkflow/fluent/func/FuncDSLUniqueIdTest.java

@@ -17,33 +17,27 @@
 
 import static io.serverlessworkflow.fluent.func.dsl.FuncDSL.agent;
 import static io.serverlessworkflow.fluent.func.dsl.FuncDSL.withUniqueId;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
 
 import io.serverlessworkflow.api.types.Task;
-import io.serverlessworkflow.api.types.TaskBase;
 import io.serverlessworkflow.api.types.TaskItem;
 import io.serverlessworkflow.api.types.Workflow;
 import io.serverlessworkflow.api.types.func.CallJava;
 import io.serverlessworkflow.api.types.func.JavaFilterFunction;
 import io.serverlessworkflow.fluent.func.dsl.UniqueIdBiFunction;
 import io.serverlessworkflow.impl.TaskContextData;
 import io.serverlessworkflow.impl.WorkflowContextData;
-import io.serverlessworkflow.impl.WorkflowDefinitionData;
 import io.serverlessworkflow.impl.WorkflowInstanceData;
-import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowPosition;
-import io.serverlessworkflow.impl.WorkflowStatus;
-import java.time.Instant;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 /**
  * Verifies that withUniqueId/agent wrap the user's function so that, at runtime, the first argument
- * is a "unique id" composed as instanceId + "-" + taskName.
+ * is a "unique id" composed as instanceId + "-" + jsonPointer (e.g., inst-123-/do/0/task).
  */
 class FuncDSLUniqueIdTest {
 
@@ -57,12 +51,12 @@ private static JavaFilterFunction<Object, Object> extractJavaFilterFunction(Call
   }
 
   @Test
-  @DisplayName("withUniqueId(name, fn, in) composes uniqueId = instanceId-taskName and passes it")
-  void withUniqueId_named_composes_and_passes_unique_id() throws Exception {
+  @DisplayName(
+      "withUniqueId(name, fn, in) composes uniqueId = instanceId-jsonPointer and passes it")
+  void withUniqueId_uses_json_pointer_for_unique_id() throws Exception {
     AtomicReference<String> receivedUniqueId = new AtomicReference<>();
     AtomicReference<String> receivedPayload = new AtomicReference<>();
 
-    // (uniqueId, payload) -> result; we capture inputs for assertion
     UniqueIdBiFunction<String, String> fn =
         (uniqueId, payload) -> {
           receivedUniqueId.set(uniqueId);
@@ -72,39 +66,45 @@ void withUniqueId_named_composes_and_passes_unique_id() throws Exception {
 
     Workflow wf =
         FuncWorkflowBuilder.workflow("wf-unique-named")
-            .tasks(
-                // important: NAME is provided → should appear in the uniqueId
-                withUniqueId("notify", fn, String.class))
+            .tasks(withUniqueId("notify", fn, String.class))
             .build();
 
     List<TaskItem> items = wf.getDo();
     assertEquals(1, items.size(), "one task expected");
     Task t = items.get(0).getTask();
     assertNotNull(t.getCallTask(), "CallTask expected");
 
-    String taskName = items.get(0).getName();
-    assertEquals("notify", taskName, "task name should be set on the step");
-
     CallJava cj = (CallJava) t.getCallTask().get();
     var jff = extractJavaFilterFunction(cj);
     assertNotNull(jff, "JavaFilterFunction must be present for withUniqueId");
 
-    // Invoke the wrapped function "as runtime" with fake contexts
-    var wctx = new FakeWorkflowContextData("inst-123");
-    var tctx = new FakeTaskContextData(taskName);
+    // Mockito stubs for runtime contexts
+    WorkflowInstanceData inst = mock(WorkflowInstanceData.class);
+    when(inst.id()).thenReturn("inst-123");
+
+    WorkflowContextData wctx = mock(WorkflowContextData.class);
+    when(wctx.instanceData()).thenReturn(inst);
+
+    // Use JSON Pointer for the unique component instead of task name
+    final String pointer = "/do/0/task";
+    WorkflowPosition pos = mock(WorkflowPosition.class);
+    when(pos.jsonPointer()).thenReturn(pointer);
+
+    TaskContextData tctx = mock(TaskContextData.class);
+    when(tctx.position()).thenReturn(pos);
 
-    // The JavaFilterFunction signature in your impl is (payload, wctx, tctx) -> result
     Object result = jff.apply("hello", wctx, tctx);
 
-    assertEquals("inst-123-notify", receivedUniqueId.get(), "uniqueId must be instanceId-taskName");
+    assertEquals(
+        "inst-123-" + pointer, receivedUniqueId.get(), "uniqueId must be instanceId-jsonPointer");
     assertEquals(
         "hello", receivedPayload.get(), "payload should be forwarded to the user function");
     assertEquals("HELLO", result, "wrapped function result should be returned");
   }
 
   @Test
-  @DisplayName("agent(fn, in) is sugar for withUniqueId(fn, in) and passes instanceId-taskName")
-  void agent_unnamed_composes_and_passes_unique_id() throws Exception {
+  @DisplayName("agent(fn, in) composes uniqueId = instanceId-jsonPointer and passes it")
+  void agent_uses_json_pointer_for_unique_id() throws Exception {
     AtomicReference<String> receivedUniqueId = new AtomicReference<>();
     AtomicReference<Integer> receivedPayload = new AtomicReference<>();
 
@@ -115,146 +115,35 @@ void agent_unnamed_composes_and_passes_unique_id() throws Exception {
           return payload + 1;
         };
 
-    Workflow wf =
-        FuncWorkflowBuilder.workflow("wf-agent")
-            .tasks(
-                // No explicit name here; builder should still set a task name,
-                // which participates in the uniqueId (instanceId-taskName)
-                agent(fn, Integer.class))
-            .build();
+    Workflow wf = FuncWorkflowBuilder.workflow("wf-agent").tasks(agent(fn, Integer.class)).build();
 
     List<TaskItem> items = wf.getDo();
     assertEquals(1, items.size(), "one task expected");
     Task t = items.get(0).getTask();
     assertNotNull(t.getCallTask(), "CallTask expected");
-    String taskName = items.get(0).getName();
-    assertNotNull(taskName, "task name should be assigned even if not explicitly provided");
 
     CallJava cj = (CallJava) t.getCallTask().get();
     var jff = extractJavaFilterFunction(cj);
     assertNotNull(jff, "JavaFilterFunction must be present for agent/withUniqueId");
 
-    WorkflowContextData wctx = new FakeWorkflowContextData("wf-999");
-    TaskContextData tctx = new FakeTaskContextData(taskName);
+    WorkflowInstanceData inst = mock(WorkflowInstanceData.class);
+    when(inst.id()).thenReturn("wf-999");
+
+    WorkflowContextData wctx = mock(WorkflowContextData.class);
+    when(wctx.instanceData()).thenReturn(inst);
+
+    final String pointer = "/do/0/task";
+    WorkflowPosition pos = mock(WorkflowPosition.class);
+    when(pos.jsonPointer()).thenReturn(pointer);
+
+    TaskContextData tctx = mock(TaskContextData.class);
+    when(tctx.position()).thenReturn(pos);
 
     Object result = jff.apply(41, wctx, tctx);
 
     assertEquals(
-        "wf-999-" + taskName,
-        receivedUniqueId.get(),
-        "agent should compose uniqueId as instanceId-taskName");
+        "wf-999-" + pointer, receivedUniqueId.get(), "uniqueId must be instanceId-jsonPointer");
     assertEquals(41, receivedPayload.get(), "payload should be forwarded to the user function");
     assertEquals(42, result, "wrapped function result should be returned");
   }
-
-  /**
-   * Minimal test doubles to satisfy the JavaFilterFunction call path. We only implement the members
-   * used by the DSL composition: - wctx.instanceData().id() - tctx.taskName()
-   */
-  static final class FakeWorkflowContextData implements WorkflowContextData {
-    private final String id;
-
-    FakeWorkflowContextData(String id) {
-      this.id = id;
-    }
-
-    @Override
-    public WorkflowInstanceData instanceData() {
-      // Provide just the id() accessor
-      return new WorkflowInstanceData() {
-        @Override
-        public String id() {
-          return id;
-        }
-
-        @Override
-        public Instant startedAt() {
-          return null;
-        }
-
-        @Override
-        public Instant completedAt() {
-          return null;
-        }
-
-        @Override
-        public WorkflowModel input() {
-          return null;
-        }
-
-        @Override
-        public WorkflowStatus status() {
-          return null;
-        }
-
-        @Override
-        public WorkflowModel output() {
-          return null;
-        }
-
-        @Override
-        public WorkflowModel context() {
-          return null;
-        }
-
-        @Override
-        public <T> T outputAs(Class<T> clazz) {
-          return null;
-        }
-      };
-    }
-
-    @Override
-    public WorkflowModel context() {
-      return null;
-    }
-
-    @Override
-    public WorkflowDefinitionData definition() {
-      return null;
-    }
-  }
-
-  record FakeTaskContextData(String taskName) implements TaskContextData {
-
-    @Override
-    public WorkflowModel input() {
-      return null;
-    }
-
-    @Override
-    public WorkflowModel rawInput() {
-      return null;
-    }
-
-    @Override
-    public TaskBase task() {
-      return null;
-    }
-
-    @Override
-    public WorkflowModel rawOutput() {
-      return null;
-    }
-
-    @Override
-    public WorkflowModel output() {
-      return null;
-    }
-
-    @Override
-    public WorkflowPosition position() {
-      return null;
-    }
-
-    @Override
-    public Instant startedAt() {
-      return null;
-    }
-
-    @Override
-    public Instant completedAt() {
-      return null;
-    }
-  }
 }