Add tests to check for update task v2 endpoint usage and fallback

Author: ajlai-orkes

src/integration-tests/WorkerRegistration.test.ts

@@ -4,6 +4,7 @@ import {
   MetadataClient,
   NonRetryableException,
   TaskHandler,
+  TaskRunner,
   WorkflowExecutor,
   clearWorkerRegistry,
   getRegisteredWorkers,
@@ -668,4 +669,56 @@ describe("SDK Worker Registration", () => {
 
     expect(getRegisteredWorkers().length).toBe(0);
   });
+
+  describeForOrkesV5("update-v2 endpoint verification", () => {
+    test("SDK detects and uses /api/tasks/update-v2 on v5 server", async () => {
+      const client = await clientPromise;
+      const taskName = `sdk_test_update_v2_verify_${Date.now()}`;
+      const workflowName = `sdk_test_update_v2_verify_wf_${Date.now()}`;
+
+      // Reset the static probe so this test measures a live response from the server,
+      // regardless of what earlier tests in this shard may have set.
+      (TaskRunner as unknown as { updateV2Available: boolean | null }).updateV2Available = null;
+
+      const taskRunner = new TaskRunner({
+        client,
+        worker: {
+          taskDefName: taskName,
+          execute: async () => ({ outputData: {}, status: "COMPLETED" }),
+        },
+        options: { pollInterval: 100, concurrency: 1, workerID: "" },
+      });
+      taskRunner.startPolling();
+
+      await executor.registerWorkflow(true, {
+        name: workflowName,
+        version: 1,
+        ownerEmail: "developers@orkes.io",
+        tasks: [simpleTask(taskName, taskName, {})],
+        inputParameters: [],
+        outputParameters: {},
+        timeoutSeconds: 0,
+      });
+      workflowsToCleanup.push({ name: workflowName, version: 1 });
+
+      const executionId = await executor.startWorkflow({
+        name: workflowName,
+        input: {},
+        version: 1,
+      });
+
+      if (!executionId) throw new Error("Execution ID is undefined");
+
+      await waitForWorkflowStatus(executor, executionId, "COMPLETED");
+      taskRunner.stopPolling();
+
+      // The workflow only reaches COMPLETED if a task update was accepted.
+      // This assertion verifies the SDK used /api/tasks/update-v2 (not the v4
+      // legacy /api/tasks fallback) — if update-v2 broke silently and the SDK
+      // fell back, this would be false.
+      expect(
+        (TaskRunner as unknown as { updateV2Available: boolean | null }).updateV2Available
+      ).toBe(true);
+    }, 60000);
+  });
 });

src/sdk/clients/worker/__tests__/TaskRunner.test.ts

@@ -27,6 +27,11 @@ jest.mock("@open-api/generated", () => ({
       error: undefined,
       response: { status: 200, ok: true },
     }),
+    updateTask: jest.fn().mockResolvedValue({
+      data: null,
+      error: undefined,
+      response: { status: 200, ok: true },
+    }),
   },
 }));
 
@@ -1459,3 +1464,142 @@ describe("V2 task chaining", () => {
     expect(mockUpdateTask).toHaveBeenCalledTimes(2);
   });
 });
+
+describe("v5/v4 backend detection", () => {
+  const makeTask = (taskId: string, workflowInstanceId = "wf-1"): Task => ({
+    taskId,
+    workflowInstanceId,
+    status: "IN_PROGRESS",
+    inputData: {},
+  });
+
+  const makeArgs = (mockClient: Client): RunnerArgs => ({
+    worker: {
+      taskDefName: "test",
+      execute: async () => ({ outputData: {}, status: "COMPLETED" }),
+    },
+    options: { pollInterval: 10, domain: "", concurrency: 1, workerID: "worker-id" },
+    logger: mockLogger,
+    client: mockClient,
+  });
+
+  test("uses updateTaskV2 when server returns 200 (v5)", async () => {
+    const mockClient = createMockClient();
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ data: [makeTask("task-1")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ data: [] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    // Default mock already returns 200 — no override needed
+
+    const runner = new TaskRunner(makeArgs(mockClient));
+    activeRunners.push(runner);
+    runner.startPolling();
+
+    await new Promise((r) => setTimeout(() => r(true), 200));
+    runner.stopPolling();
+
+    expect(TaskResource.updateTaskV2).toHaveBeenCalledTimes(1);
+    expect(TaskResource.updateTask).not.toHaveBeenCalled();
+    expect(
+      (TaskRunner as unknown as { updateV2Available: boolean | null }).updateV2Available
+    ).toBe(true);
+  });
+
+  test("falls back to updateTask when server returns 404 (v4 — endpoint absent)", async () => {
+    const mockClient = createMockClient();
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ data: [makeTask("task-1")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ data: [] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    (TaskResource.updateTaskV2 as jest.MockedFunction<typeof TaskResource.updateTaskV2>)
+      .mockResolvedValue({ data: null, error: undefined, response: { status: 404, ok: false } } as Awaited<ReturnType<typeof TaskResource.updateTaskV2>>);
+
+    const runner = new TaskRunner(makeArgs(mockClient));
+    activeRunners.push(runner);
+    runner.startPolling();
+
+    await new Promise((r) => setTimeout(() => r(true), 200));
+    runner.stopPolling();
+
+    // Probed once, then fell back
+    expect(TaskResource.updateTaskV2).toHaveBeenCalledTimes(1);
+    expect(TaskResource.updateTask).toHaveBeenCalledTimes(1);
+    expect(
+      (TaskRunner as unknown as { updateV2Available: boolean | null }).updateV2Available
+    ).toBe(false);
+  });
+
+  test("falls back to updateTask when server returns 405 (v4 — wrong method)", async () => {
+    const mockClient = createMockClient();
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ data: [makeTask("task-1")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ data: [] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    (TaskResource.updateTaskV2 as jest.MockedFunction<typeof TaskResource.updateTaskV2>)
+      .mockResolvedValue({ data: null, error: undefined, response: { status: 405, ok: false } } as Awaited<ReturnType<typeof TaskResource.updateTaskV2>>);
+
+    const runner = new TaskRunner(makeArgs(mockClient));
+    activeRunners.push(runner);
+    runner.startPolling();
+
+    await new Promise((r) => setTimeout(() => r(true), 200));
+    runner.stopPolling();
+
+    expect(TaskResource.updateTaskV2).toHaveBeenCalledTimes(1);
+    expect(TaskResource.updateTask).toHaveBeenCalledTimes(1);
+    expect(
+      (TaskRunner as unknown as { updateV2Available: boolean | null }).updateV2Available
+    ).toBe(false);
+  });
+
+  test("skips probe on subsequent tasks after v5 detection — uses updateTaskV2 directly", async () => {
+    const mockClient = createMockClient();
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ data: [makeTask("task-1")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValueOnce({ data: [makeTask("task-2")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ data: [] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    // Explicitly reset to 200: jest.clearAllMocks() preserves mockResolvedValue overrides
+    // from previous tests (e.g. the 405-fallback test), so we cannot rely on the module-level
+    // default here.
+    (TaskResource.updateTaskV2 as jest.MockedFunction<typeof TaskResource.updateTaskV2>)
+      .mockResolvedValue({ data: null, error: undefined, response: { status: 200, ok: true } } as Awaited<ReturnType<typeof TaskResource.updateTaskV2>>);
+
+    const runner = new TaskRunner(makeArgs(mockClient));
+    activeRunners.push(runner);
+    runner.startPolling();
+
+    await new Promise((r) => setTimeout(() => r(true), 300));
+    runner.stopPolling();
+
+    expect(TaskResource.updateTaskV2).toHaveBeenCalledTimes(2);
+    expect(TaskResource.updateTask).not.toHaveBeenCalled();
+  });
+
+  test("skips probe on subsequent tasks after v4 detection — uses updateTask directly", async () => {
+    const mockClient = createMockClient();
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ data: [makeTask("task-1")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValueOnce({ data: [makeTask("task-2")] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ data: [] } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    (TaskResource.updateTaskV2 as jest.MockedFunction<typeof TaskResource.updateTaskV2>)
+      .mockResolvedValue({ data: null, error: undefined, response: { status: 405, ok: false } } as Awaited<ReturnType<typeof TaskResource.updateTaskV2>>);
+
+    const runner = new TaskRunner(makeArgs(mockClient));
+    activeRunners.push(runner);
+    runner.startPolling();
+
+    await new Promise((r) => setTimeout(() => r(true), 300));
+    runner.stopPolling();
+
+    // Probe fires once for task-1, then task-2 goes directly to updateTask
+    expect(TaskResource.updateTaskV2).toHaveBeenCalledTimes(1);
+    expect(TaskResource.updateTask).toHaveBeenCalledTimes(2);
+  });
+});