Ensure concurrency is a valid number

Author: ajlai-orkes

src/sdk/clients/worker/Poller.ts

@@ -33,6 +33,14 @@ export class Poller<T> {
     this.performWorkFunction = performWorkFunction;
     this.options = { ...this.options, ...pollerOptions };
     this.logger = logger || noopLogger;
+    
+    // Ensure concurrency is a valid number
+    if (typeof this.options.concurrency !== 'number' || isNaN(this.options.concurrency) || this.options.concurrency < 1) {
+      this.logger.info(
+        `Invalid concurrency value (${this.options.concurrency}) for poller ${pollerId}. Using default: ${DEFAULT_CONCURRENCY}`
+      );
+      this.options.concurrency = DEFAULT_CONCURRENCY;
+    }
   }
 
   get isPolling() {
@@ -77,12 +85,10 @@ export class Poller<T> {
     while (this.isPolling) {
       try {
         // Concurrency could have been updated. Accounting for that
-        const count = Math.max(
-          0,
-          this.options.concurrency - this._tasksInProcess
-        );
+        const rawCount = (this.options.concurrency ?? DEFAULT_CONCURRENCY) - this._tasksInProcess;
+        const count = Math.max(0, Number.isFinite(rawCount) ? rawCount : DEFAULT_CONCURRENCY);
 
-        if (count === 0) {
+        if (count === 0 || !Number.isFinite(count)) {
           this.logger.debug(
             "Max in process reached, Will skip polling for " + this._pollerId
           );

src/sdk/clients/worker/TaskRunner.ts

@@ -73,8 +73,8 @@ export class TaskRunner {
       this.batchPoll,
       this.executeTask,
       {
-        concurrency: worker.concurrency ?? options.concurrency,
-        pollInterval: worker.pollInterval ?? options.pollInterval,
+        concurrency: worker.concurrency ?? this.options.concurrency,
+        pollInterval: worker.pollInterval ?? this.options.pollInterval,
       },
       this.logger
     );

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

@@ -1087,4 +1087,75 @@ describe("Polling state", () => {
 
     expect(runner.isPolling).toBe(false);
   });
+
+  test("handles undefined concurrency by using default", async () => {
+    const mockClient = createMockClient();
+    
+    // Create worker with undefined concurrency
+    const args: RunnerArgs = {
+      worker: {
+        taskDefName: "test-undefined-concurrency",
+        execute: async () => ({
+          status: "COMPLETED",
+          outputData: { result: "ok" },
+        }),
+        // concurrency is intentionally undefined
+      },
+      options: {
+        pollInterval: 10,
+        workerID: "test-worker",
+        // concurrency is also undefined here
+      },
+      logger: mockLogger,
+      client: mockClient,
+    };
+
+    const mockTask: Task = {
+      taskId: "task-1",
+      workflowInstanceId: "workflow-1",
+      status: "IN_PROGRESS",
+      taskType: "test-undefined-concurrency",
+      inputData: {},
+    } as Task;
+
+    (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>)
+      .mockResolvedValueOnce({ 
+        data: [mockTask],
+        request: {} as Request,
+        response: {} as Response,
+      } as Awaited<ReturnType<typeof TaskResource.batchPoll>>)
+      .mockResolvedValue({ 
+        data: [],
+        request: {} as Request,
+        response: {} as Response,
+      } as Awaited<ReturnType<typeof TaskResource.batchPoll>>);
+
+    (TaskResource.updateTask as jest.MockedFunction<typeof TaskResource.updateTask>)
+      .mockResolvedValue({ 
+        data: null,
+        request: {} as Request,
+        response: {} as Response,
+      } as Awaited<ReturnType<typeof TaskResource.updateTask>>);
+
+    const runner = new TaskRunner(args);
+    activeRunners.push(runner);
+
+    runner.startPolling();
+    
+    // Wait for polling cycle
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    await runner.stopPolling();
+
+    // Verify batchPoll was called with a valid count (should be 1, the default concurrency)
+    expect(TaskResource.batchPoll).toHaveBeenCalled();
+    const batchPollCall = (TaskResource.batchPoll as jest.MockedFunction<typeof TaskResource.batchPoll>).mock.calls[0];
+    const queryParams = batchPollCall?.[0]?.query;
+    
+    // Verify count is a valid number, not NaN
+    expect(queryParams?.count).toBeDefined();
+    expect(typeof queryParams?.count).toBe('number');
+    expect(Number.isFinite(queryParams?.count)).toBe(true);
+    expect(queryParams?.count).toBeGreaterThan(0);
+  });
 });