Separate unit, integration (v4/v5) tests; Run tests on Node 20, 22, 24; Add retry for HTTP 429 error

.github/workflows/pull_request.yml

@@ -19,25 +19,32 @@ jobs:
 
   tests:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20, 22, 24]
+        test: ["unit", "integration:v5", "integration:v4"]
+    name: Node.js v${{ matrix.node-version }} - ${{ matrix.test }} tests
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Set up Node
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
+          node-version: ${{ matrix.node-version }}
       - name: Install Dependencies
         run: npm ci
-      - name: Run Tests and Add Annotations
-        run: npm test -- --ci --reporters=default --reporters=github-actions --reporters=jest-junit
+      - name: Run ${{ matrix.test }} Tests and Add Annotations
+        run: npm run test:${{ matrix.test }} -- --ci --reporters=default --reporters=github-actions --reporters=jest-junit
         env:
-          CONDUCTOR_SERVER_URL: ${{ vars.SERVER_URL }}
-          CONDUCTOR_AUTH_KEY: ${{ secrets.AUTH_KEY }}
-          CONDUCTOR_AUTH_SECRET: ${{ secrets.AUTH_SECRET }}
-      - name: Publish Dorny Test Results Summary
+          CONDUCTOR_SERVER_URL: ${{ matrix.test == 'integration:v4' && vars.SERVER_URL_V4 || vars.SERVER_URL }}
+          CONDUCTOR_AUTH_KEY: ${{ matrix.test == 'integration:v4' && secrets.AUTH_KEY_V4 || secrets.AUTH_KEY }}
+          CONDUCTOR_AUTH_SECRET: ${{ matrix.test == 'integration:v4' && secrets.AUTH_SECRET_V4 || secrets.AUTH_SECRET }}
+          JEST_JUNIT_OUTPUT_NAME: ${{ matrix.test }}-test-results.xml
+      - name: Publish ${{ matrix.test }} Test Results
         uses: dorny/test-reporter@v2
         if: ${{ !cancelled() }}
         with:
-          name: Test report
-          path: reports/jest-junit.xml
+          name: ${{ matrix.test }} Test Report
+          path: reports/${{ matrix.test }}-test-results.xml
           reporter: jest-junit

src/common/open-api/__test__/EventResourceService.test.ts → integration-tests/common/EventResourceService.test.ts

@@ -1,14 +1,14 @@
 import { expect, describe, test } from "@jest/globals";
-import { orkesConductorClient } from "../../../orkes";
+import { orkesConductorClient } from "../../src/orkes";
 
 describe("EventResourceService", () => {
   test("Should create an event handler with description and tags and then delete it", async () => {
     const orkesClient = await orkesConductorClient();
     const eventApi = orkesClient.eventResource;
 
     const [eventName, event, eventDescription, eventTagKey, eventTagValue] = [
-      "jsSdkTestEventName",
-      "jsSdkTest:eventHandler:1",
+      `jsSdkTest-EventName-${Date.now()}`,
+      `jsSdkTest:eventHandler:1${Date.now()}`,
       "jsSdkTestDescription",
       "jsSdkTestTagKey",
       "jsSdkTestTagValue",

src/core/__test__/MetadataClient.test.ts → integration-tests/common/MetadataClient.test.ts

@@ -1,18 +1,19 @@
 import { expect, describe, test, jest } from "@jest/globals";
-import { MetadataClient } from "../metadataClient";
-import { taskDefinition } from "../sdk";
-import { orkesConductorClient } from "../../orkes";
+import { MetadataClient } from "../../src/core/metadataClient";
+import { taskDefinition } from "../../src/core/sdk";
+import { orkesConductorClient } from "../../src/orkes";
 
 describe("MetadataClient", () => {
   const clientPromise = orkesConductorClient();
+  const taskName = `jsSdkTest-test_task_definition-${Date.now()}`;
 
   jest.setTimeout(15000);
   test("Should register a task definition", async () => {
     const client = await clientPromise;
     const metadataClient = new MetadataClient(client);
 
     const newTaskDefinition = taskDefinition({
-      name: "test_task_definition",
+      name: taskName,
       description: "New Task Definition",
       retryCount: 4,
       timeoutSeconds: 7200,
@@ -62,7 +63,7 @@ describe("MetadataClient", () => {
     const metadataClient = new MetadataClient(client);
 
     const newTaskDefinition = taskDefinition({
-      name: "test_task_definition",
+      name: taskName,
       description: "New Task Definition Update",
       retryCount: 5,
       timeoutSeconds: 7201,
@@ -110,14 +111,13 @@ describe("MetadataClient", () => {
   test("Should unregister a task definition", async () => {
     const client = await clientPromise;
     const metadataClient = new MetadataClient(client);
-    const name ="test_task_definition";
 
     await expect(
-      metadataClient.unregisterTask("test_task_definition")
+      metadataClient.unregisterTask(taskName)
     ).resolves.not.toThrow();
 
     await expect(client.metadataResource.getTaskDef(
-      name
+      taskName
     )).rejects.toThrow();
   })
 });

src/task/__tests__/TaskManager.test.ts → integration-tests/common/TaskManager.test.ts

@@ -1,23 +1,25 @@
 import { expect, describe, test, jest } from "@jest/globals";
-import { simpleTask, taskDefinition, WorkflowExecutor } from "../../core";
-import { orkesConductorClient } from "../../orkes";
-import { TaskManager, ConductorWorker } from "../index";
-import { mockLogger } from "./mockLogger";
-import { TestUtil } from "../../core/__test__/utils/test-util";
+import { simpleTask, taskDefinition, WorkflowExecutor } from "../../src/core";
+import { orkesConductorClient } from "../../src/orkes";
+import { TaskManager, ConductorWorker } from "../../src/task/index";
+import { mockLogger } from "../utils/mockLogger";
+import { TestUtil } from "../utils/test-util";
 
 
-const BASE_TIME = 500;
+const BASE_TIME = 1000;
 describe("TaskManager", () => {
   const clientPromise = orkesConductorClient();
 
-  jest.setTimeout(15000);
+  jest.setTimeout(30000);
 
   test("Should run workflow with worker", async () => {
     const client = await clientPromise;
     const executor = new WorkflowExecutor(client);
+    const taskName = `jsSdkTest-taskmanager-test-${Date.now()}`;
+    const workflowName = `jsSdkTest-taskmanager-test-wf-${Date.now()}`;
 
     const worker: ConductorWorker = {
-      taskDefName: "taskmanager-test",
+      taskDefName: taskName,
       execute: async () => {
         return {
           outputData: {
@@ -34,22 +36,22 @@ describe("TaskManager", () => {
     manager.startPolling();
 
     await executor.registerWorkflow(true, {
-      name: "TaskManagerTest",
+      name: workflowName,
       version: 1,
       ownerEmail: "developers@orkes.io",
-      tasks: [simpleTask("taskmanager-test", "taskmanager-test", {})],
+      tasks: [simpleTask(taskName, taskName, {})],
       inputParameters: [],
       outputParameters: {},
       timeoutSeconds: 0,
     });
 
     const executionId = await executor.startWorkflow({
-      name: "TaskManagerTest",
+      name: workflowName,
       input: {},
       version: 1,
     });
 
-    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 4);
+    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 30);
 
     expect(workflowStatus.status).toEqual("COMPLETED");
 
@@ -59,18 +61,20 @@ describe("TaskManager", () => {
   test("On error it should call the errorHandler provided", async () => {
     const client = await clientPromise;
     const executor = new WorkflowExecutor(client);
+    const taskName = `jsSdkTest-taskmanager-error-handler-test-${Date.now()}`;
+    const workflowName = `jsSdkTest-taskmanager-error-handler-test-wf-${Date.now()}`;
 
     const mockErrorHandler = jest.fn();
 
     const worker: ConductorWorker = {
-      taskDefName: "taskmanager-error-handler-test-unique",
+      taskDefName: taskName,
       execute: async () => {
         throw new Error("This is a forced error for testing error handler");
       },
     };
 
     await client.metadataResource.registerTaskDef([taskDefinition({
-      name: "taskmanager-error-handler-test-unique",
+      name: taskName,
       timeoutSeconds: 0,
       retryCount: 0,
     })]);
@@ -83,23 +87,23 @@ describe("TaskManager", () => {
     manager.startPolling();
 
     await executor.registerWorkflow(true, {
-      name: "TaskManagerTestErrorHandlerUnique",
+      name: workflowName,
       version: 1,
       ownerEmail: "developers@orkes.io",
-      tasks: [simpleTask("taskmanager-error-handler-test-unique", "taskmanager-error-handler-test-unique", {})],
+      tasks: [simpleTask(taskName, taskName, {})],
       inputParameters: [],
       outputParameters: {},
       timeoutSeconds: 0,
     });
 
     const status = await executor.startWorkflow({
-      name: "TaskManagerTestErrorHandlerUnique",
+      name: workflowName,
       input: {},
       version: 1,
-      correlationId: "errorHandlerTestIdentifierUnique"
+      correlationId: `${workflowName}-id`
     });
 
-    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, status, BASE_TIME * 6);
+    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, status, BASE_TIME * 30);
 
     expect(workflowStatus.status).toEqual("FAILED");
     expect(mockErrorHandler).toHaveBeenCalledTimes(1);
@@ -109,16 +113,18 @@ describe("TaskManager", () => {
   test("If no error handler provided. it should just update the task", async () => {
     const client = await clientPromise;
     const executor = new WorkflowExecutor(client);
+    const taskName = `jsSdkTest-taskmanager-error-test-${Date.now()}`;
+    const workflowName = `jsSdkTest-taskmanager-error-test-wf-${Date.now()}`;
 
     const worker: ConductorWorker = {
-      taskDefName: "taskmanager-error-test",
+      taskDefName: taskName,
       execute: async () => {
         throw new Error("This is a forced error");
       },
     };
 
     await client.metadataResource.registerTaskDef([taskDefinition({
-      name: "taskmanager-error-test",
+      name: taskName,
       timeoutSeconds: 0,
       retryCount: 0,
     })]);
@@ -130,23 +136,23 @@ describe("TaskManager", () => {
     manager.startPolling();
 
     await executor.registerWorkflow(true, {
-      name: "TaskManagerTestE",
+      name: workflowName,
       version: 1,
       ownerEmail: "developers@orkes.io",
-      tasks: [simpleTask("taskmanager-error-test", "taskmanager-error-test", {})],
+      tasks: [simpleTask(taskName, taskName, {})],
       inputParameters: [],
       outputParameters: {},
       timeoutSeconds: 0,
     });
 
     const executionId = await executor.startWorkflow({
-      name: "TaskManagerTestE",
+      name: workflowName,
       input: {},
       version: 1,
-      correlationId: "noErrorHandlerProvidedIdentifier"
+      correlationId: `${workflowName}-id`
     });
 
-    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId!, BASE_TIME * 10);
+    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId!, BASE_TIME * 30);
     expect(workflowStatus.status).toEqual("FAILED");
     await manager.stopPolling();
   });
@@ -158,7 +164,7 @@ describe("TaskManager", () => {
     // just create a bunch of worker names
     const workerNames: string[] = Array.from({ length: 3 })
       .fill(0)
-      .map((_, i: number) => `taskman-multi-${1 + i}`);
+      .map((_, i: number) => `jsSdkTest-taskman-multi-${1 + i}-${Date.now()}`);
 
     // names to actual workers
     const workers: ConductorWorker[] = workerNames.map((name) => ({
@@ -183,7 +189,7 @@ describe("TaskManager", () => {
 
     expect(manager.isPolling).toBeTruthy();
 
-    const workflowName = "TaskManagerTestMulti";
+    const workflowName = `jsSdkTest-taskmanager-multi-test-wf-${Date.now()}`;
 
     // increase polling speed
     manager.updatePollingOptions({ concurrency: 4 });
@@ -203,15 +209,15 @@ describe("TaskManager", () => {
     const executionId = await executor.startWorkflow({
       name: workflowName,
       version: 1,
-      correlationId: "identifierTaskManMulti"
+      correlationId: `${workflowName}-id`
     });
 
     expect(executionId).toBeDefined();
 
     // decrease speed again
     manager.updatePollingOptions({ pollInterval: BASE_TIME, concurrency: 1 });
 
-    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 4);
+    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 30);
 
     expect(workflowStatus.status).toEqual("COMPLETED");
     await manager.stopPolling();
@@ -233,10 +239,11 @@ describe("TaskManager", () => {
 
   test("Should not be able to startPolling if duplicate workers", async () => {
     const client = await clientPromise;
+    const workerName = `jsSdkTest-worker-name-${Date.now()}`;
 
     const workerNames: string[] = Array.from({ length: 3 })
       .fill(0)
-      .map(() => `worker-name`);
+      .map(() => workerName);
 
     // names to actual workers
     const workers: ConductorWorker[] = workerNames.map((name) => ({
@@ -255,20 +262,21 @@ describe("TaskManager", () => {
       options: { pollInterval: BASE_TIME, concurrency: 2 },
     });
     expect(() => manager.startPolling()).toThrow(
-      "Duplicate worker taskDefName: worker-name"
+      `Duplicate worker taskDefName: ${workerName}`
     );
   });
 
   test("Updates single worker properties", async () => {
     const client = await clientPromise;
 
     const executor = new WorkflowExecutor(client);
+    const workerName = `jsSdkTest-taskman-single-worker-update-${Date.now()}`;
     // just create a bunch of worker names
     const workerNames: string[] = Array.from({ length: 3 })
       .fill(0)
-      .map((_, i: number) => `taskman-single-worker-update${1 + i}`);
+      .map((_, i: number) => `${workerName}-${1 + i}`);
 
-    const candidateWorkerUpdate = "taskman-single-worker-update1";
+    const candidateWorkerUpdate = `${workerName}-1`;
     const initialCandidateWorkflowOptions = {
       concurrency: 1,
       pollInterval: BASE_TIME * 3,
@@ -300,7 +308,7 @@ describe("TaskManager", () => {
 
     expect(manager.isPolling).toBeTruthy();
 
-    const workflowName = "TaskManagerTestMultiSingleWorkerUpdate";
+    const workflowName = `jsSdkTest-taskmanager-multi-single-worker-update-wf-${Date.now()}`;
 
     const updatedWorkerOptions = {
       concurrency: 3,
@@ -328,14 +336,14 @@ describe("TaskManager", () => {
     const executionId = await executor.startWorkflow({
       name: workflowName,
       version: 1,
-      correlationId: "identifierTaskManMulti"
+      correlationId: `${workflowName}-id`
     });
     expect(executionId).toBeDefined();
 
     // decrease speed again
     manager.updatePollingOptions({ pollInterval: BASE_TIME, concurrency: 1 });
 
-    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 10);
+    const workflowStatus = await TestUtil.waitForWorkflowCompletion(executor, executionId, BASE_TIME * 30);
 
     expect(workflowStatus.status).toEqual("COMPLETED");
     await manager.stopPolling();