opticedge-cloud-utils 1.1.13 → 1.1.15

package/tests/task.test.ts

@@ -1,337 +1,337 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// tests/createTask.retry.test.ts
-const mockCreateTask = jest.fn()
-const mockQueuePath = jest.fn(
-  (projectId: string, region: string, queueId: string) =>
-    `projects/${projectId}/locations/${region}/queues/${queueId}`
-)
-
-// Mock Cloud Tasks client and protos (same as your original file)
-jest.mock('@google-cloud/tasks', () => {
-  return {
-    CloudTasksClient: jest.fn(() => ({
-      createTask: mockCreateTask,
-      queuePath: mockQueuePath
-    })),
-    protos: {
-      google: {
-        cloud: {
-          tasks: {
-            v2: {
-              HttpMethod: {
-                POST: 'POST'
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-})
-
-// Mock the retry module so tests can inspect how createTask uses it.
-// We'll set mockRetry behavior in each test as needed.
-const realRetryModule = jest.requireActual('../src/retry') as typeof import('../src/retry')
-const mockRetry = jest.fn()
-
-jest.mock('../src/retry', () => ({
-  // spread real exports so isRetryableDefault, isRetryableAxios etc remain available
-  ...realRetryModule,
-  // override only 'retry' with our mock
-  retry: (...args: any[]) => mockRetry(...args)
-}))
-
-import { createTask, isRetryableCloudTasks } from '../src/task'
-
-describe('isRetryableCloudTasks', () => {
-  test('returns false for falsy errors', () => {
-    expect(isRetryableCloudTasks(null)).toBe(false)
-    expect(isRetryableCloudTasks(undefined)).toBe(false)
-    // other falsy-ish values should also be non-retryable
-    expect(isRetryableCloudTasks(false as any)).toBe(false)
-    expect(isRetryableCloudTasks('' as any)).toBe(false)
-  })
-
-  test('treats ALREADY_EXISTS (code: 6) as NOT retryable', () => {
-    expect(isRetryableCloudTasks({ code: 6 })).toBe(false)
-    expect(isRetryableCloudTasks({ grpcCode: 6 })).toBe(false)
-    expect(isRetryableCloudTasks({ code: 'ALREADY_EXISTS' })).toBe(false)
-    expect(isRetryableCloudTasks({ code: 'already_exists' })).toBe(false)
-  })
-
-  test('treats UNAVAILABLE (code: 14) as retryable', () => {
-    expect(isRetryableCloudTasks({ code: 14 })).toBe(true)
-    expect(isRetryableCloudTasks({ grpcCode: 14 })).toBe(true)
-  })
-
-  test('treats HTTP 5xx and 429 as retryable, 4xx not retryable', () => {
-    expect(isRetryableCloudTasks({ response: { status: 500 } })).toBe(true)
-    expect(isRetryableCloudTasks({ response: { status: 503 } })).toBe(true)
-    expect(isRetryableCloudTasks({ response: { status: 429 } })).toBe(true)
-
-    expect(isRetryableCloudTasks({ response: { status: 400 } })).toBe(false)
-    expect(isRetryableCloudTasks({ response: { status: 404 } })).toBe(false)
-  })
-
-  test('treats node network errno like ECONNRESET as retryable (delegated to isRetryableDefault)', () => {
-    // isRetryableDefault recognizes typical node syscodes like 'ECONNRESET'
-    expect(isRetryableCloudTasks({ code: 'ECONNRESET' })).toBe(true)
-    expect(isRetryableCloudTasks({ code: 'ETIMEDOUT' })).toBe(true)
-    expect(isRetryableCloudTasks({ code: 'EAI_AGAIN' })).toBe(true)
-  })
-
-  test('plain Error without hints is not retryable', () => {
-    expect(isRetryableCloudTasks(new Error('oops'))).toBe(false)
-  })
-
-  test('non-standard objects without response but with message may or may not be retryable depending on heuristics', () => {
-    // This test documents the expected behavior: a message-only error generally is NOT retryable
-    // unless the message contains a retryable substring (e.g. "timeout" or "unavailable").
-    expect(isRetryableCloudTasks({ message: 'socket closed' })).toBe(false)
-    expect(isRetryableCloudTasks({ message: 'request timed out' })).toBe(true)
-    expect(isRetryableCloudTasks({ message: 'temporarily unavailable' })).toBe(true)
-  })
-})
-
-describe('createTask (with retry)', () => {
-  const projectId = 'test-project'
-  const region = 'us-central1'
-  const queueId = 'test-queue'
-  const data = { test: 'data' }
-  const serviceAccount = 'test-sa@test.iam.gserviceaccount.com'
-  const audience = 'https://run-url'
-  const mockTaskName =
-    'projects/test-project/locations/us-central1/queues/test-queue/tasks/task-123'
-
-  let warnSpy: jest.SpyInstance
-
-  beforeEach(() => {
-    mockCreateTask.mockReset()
-    mockQueuePath.mockClear()
-    mockRetry.mockReset()
-    // store the spy instance so we can assert against it safely
-    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
-  })
-
-  it('throws error if any required parameter is missing', async () => {
-    // Ensure retry / createTask are not called for parameter validation errors
-    await expect(
-      createTask('', 'region', 'queue', {}, 'serviceAccount', 'audience')
-    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
-
-    await expect(
-      createTask('project', '', 'queue', {}, 'serviceAccount', 'audience')
-    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
-
-    await expect(
-      createTask('project', 'region', '', {}, 'serviceAccount', 'audience')
-    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
-
-    await expect(createTask('project', 'region', 'queue', {}, '', 'audience')).rejects.toThrow(
-      'Missing required parameters for Cloud Tasks setup'
-    )
-
-    await expect(
-      createTask('project', 'region', 'queue', {}, 'serviceAccount', '')
-    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
-
-    expect(mockCreateTask).not.toHaveBeenCalled()
-    expect(mockRetry).not.toHaveBeenCalled()
-  })
-
-  it('should create a task and return task name (calls retry once)', async () => {
-    // Configure retry mock to simply execute the provided function immediately.
-    mockRetry.mockImplementation(async (fn: () => any) => {
-      return await fn()
-    })
-
-    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
-
-    expect(result).toBe(mockTaskName)
-    expect(mockCreateTask).toHaveBeenCalledTimes(1)
-    expect(mockRetry).toHaveBeenCalledTimes(1)
-    // ensure the createTask was called with an object containing `task`
-    const calledArg = mockCreateTask.mock.calls[0][0]
-    expect(calledArg).toHaveProperty('task')
-  })
-
-  it('should throw error if task name is missing', async () => {
-    mockRetry.mockImplementation(async (fn: () => any) => {
-      return await fn()
-    })
-    mockCreateTask.mockResolvedValue([{}]) // Simulate missing name
-
-    await expect(
-      createTask(projectId, region, queueId, { foo: 'bar' }, serviceAccount, audience)
-    ).rejects.toThrow('Failed to create task: no name returned')
-  })
-
-  it('should include scheduleTime if delaySeconds is set', async () => {
-    mockRetry.mockImplementation(async (fn: () => any) => await fn())
-    mockCreateTask.mockResolvedValue([
-      { name: 'projects/test/locations/us-central1/queues/test/tasks/task-456' }
-    ])
-
-    const delaySeconds = 120
-    const before = Math.floor(Date.now() / 1000) + delaySeconds
-
-    await createTask(
-      projectId,
-      region,
-      queueId,
-      { message: 'delayed' },
-      serviceAccount,
-      audience,
-      delaySeconds
-    )
-
-    const taskArg = mockCreateTask.mock.calls[0][0].task
-    const scheduleTime = taskArg.scheduleTime?.seconds
-
-    const after = Math.floor(Date.now() / 1000) + delaySeconds
-
-    expect(typeof scheduleTime).toBe('number')
-    expect(scheduleTime).toBeGreaterThanOrEqual(before)
-    expect(scheduleTime).toBeLessThanOrEqual(after)
-  })
-
-  it('retries on transient (UNAVAILABLE) error then succeeds', async () => {
-    // Simulate createTask: first call rejects with transient code 14, second call resolves.
-    mockCreateTask
-      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' })
-      .mockResolvedValueOnce([{ name: mockTaskName }])
-
-    // Implement a small retry simulator: call fn(); if it throws then call opts.onRetry and call fn() again.
-    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
-      try {
-        return await fn()
-      } catch (err) {
-        // simulate onRetry callback being invoked by retry implementation
-        if (opts?.onRetry) {
-          try {
-            opts.onRetry(err, 1, 0)
-          } catch {
-            // ignore
-          }
-        }
-        return await fn()
-      }
-    })
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
-
-    expect(mockCreateTask).toHaveBeenCalledTimes(2)
-    expect(mockRetry).toHaveBeenCalledTimes(1)
-    expect(result).toBe(mockTaskName)
-  })
-
-  it('returns expected name if ALREADY_EXISTS and taskId provided (idempotent)', async () => {
-    // Simulate retry throwing ALREADY_EXISTS error (code: 6)
-    mockRetry.mockImplementation(async () => {
-      throw { code: 6, message: 'ALREADY_EXISTS' }
-    })
-
-    const taskId = 'task-123'
-    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/${taskId}`
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience, 0, {
-      taskId
-    })
-
-    // Should return expected name when ALREADY_EXISTS and taskId provided
-    expect(result).toBe(expectedName)
-    expect(mockRetry).toHaveBeenCalledTimes(1)
-  })
-
-  it('passes an isRetryable to retry that treats ALREADY_EXISTS as non-retryable and UNAVAILABLE as retryable', async () => {
-    // Spy on the options passed to retry and invoke isRetryable with sample errors
-    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
-      // Sanity: opts should exist and include isRetryable
-      expect(opts).toBeDefined()
-      expect(typeof opts.isRetryable).toBe('function')
-
-      const isRetryable = opts.isRetryable
-
-      // ALREADY_EXISTS (gRPC code 6) should NOT be retryable
-      expect(isRetryable({ code: 6 })).toBe(false)
-      // UNAVAILABLE (gRPC code 14) should be retryable
-      expect(isRetryable({ code: 14 })).toBe(true)
-
-      expect(isRetryable({ code: 'ECONNRESET' })).toBe(true)
-
-      // Execute the function normally for this test
-      return await fn()
-    })
-
-    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
-    expect(result).toBe(mockTaskName)
-    expect(mockRetry).toHaveBeenCalledTimes(1)
-  })
-
-  it('invokes onRetry with actual error message and logs it', async () => {
-    // first call fails with a retryable transient error, second call succeeds
-    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/1`
-    mockCreateTask
-      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' }) // transient
-      .mockResolvedValueOnce([{ name: expectedName }])
-
-    // Simulate retry behaviour: call fn(); if it throws, call onRetry(err, attempt, delay) then try fn() again.
-    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
-      try {
-        return await fn()
-      } catch (err) {
-        if (opts?.onRetry) {
-          opts.onRetry(err, 1, 0)
-        }
-        return await fn()
-      }
-    })
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
-    expect(result).toBe(expectedName)
-    expect(mockCreateTask).toHaveBeenCalledTimes(2)
-
-    // assert onRetry logged the attempt and included the error message
-    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
-    const warnMsg = warnSpy.mock.calls[0][0] as string
-    expect(warnMsg).toContain('createTask retry #1 in 0ms')
-    expect(warnMsg).toContain('UNAVAILABLE')
-  })
-
-  it('invokes onRetry with undefined error and logs "undefined" in message', async () => {
-    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/2`
-    mockCreateTask
-      .mockRejectedValueOnce(new Error('boom')) // this will trigger catch in our mockRetry
-      .mockResolvedValueOnce([{ name: expectedName }])
-
-    // This variant calls onRetry(undefined, ...) to exercise the err?.message ?? err branch.
-    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
-      try {
-        return await fn()
-      } catch {
-        if (opts?.onRetry) {
-          opts.onRetry(undefined, 1, 0) // pass undefined as the error
-        }
-        return await fn()
-      }
-    })
-
-    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
-    expect(result).toBe(expectedName)
-    expect(mockCreateTask).toHaveBeenCalledTimes(2)
-
-    // Assert the onRetry prefix was logged
-    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
-    const warnMsg = warnSpy.mock.calls[0][0] as string
-    expect(warnMsg).toContain('createTask retry #1 in 0ms')
-
-    // instead of requiring the exact 'undefined' substring (which can vary),
-    // assert there's something logged in the error slot (non-empty)
-    const afterPrefix = warnMsg.replace('createTask retry #1 in 0ms — ', '')
-    expect(afterPrefix.length).toBeGreaterThan(0)
-  })
-})
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// tests/createTask.retry.test.ts
+const mockCreateTask = jest.fn()
+const mockQueuePath = jest.fn(
+  (projectId: string, region: string, queueId: string) =>
+    `projects/${projectId}/locations/${region}/queues/${queueId}`
+)
+
+// Mock Cloud Tasks client and protos (same as your original file)
+jest.mock('@google-cloud/tasks', () => {
+  return {
+    CloudTasksClient: jest.fn(() => ({
+      createTask: mockCreateTask,
+      queuePath: mockQueuePath
+    })),
+    protos: {
+      google: {
+        cloud: {
+          tasks: {
+            v2: {
+              HttpMethod: {
+                POST: 'POST'
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+})
+
+// Mock the retry module so tests can inspect how createTask uses it.
+// We'll set mockRetry behavior in each test as needed.
+const realRetryModule = jest.requireActual('../src/retry') as typeof import('../src/retry')
+const mockRetry = jest.fn()
+
+jest.mock('../src/retry', () => ({
+  // spread real exports so isRetryableDefault, isRetryableAxios etc remain available
+  ...realRetryModule,
+  // override only 'retry' with our mock
+  retry: (...args: any[]) => mockRetry(...args)
+}))
+
+import { createTask, isRetryableCloudTasks } from '../src/task'
+
+describe('isRetryableCloudTasks', () => {
+  test('returns false for falsy errors', () => {
+    expect(isRetryableCloudTasks(null)).toBe(false)
+    expect(isRetryableCloudTasks(undefined)).toBe(false)
+    // other falsy-ish values should also be non-retryable
+    expect(isRetryableCloudTasks(false as any)).toBe(false)
+    expect(isRetryableCloudTasks('' as any)).toBe(false)
+  })
+
+  test('treats ALREADY_EXISTS (code: 6) as NOT retryable', () => {
+    expect(isRetryableCloudTasks({ code: 6 })).toBe(false)
+    expect(isRetryableCloudTasks({ grpcCode: 6 })).toBe(false)
+    expect(isRetryableCloudTasks({ code: 'ALREADY_EXISTS' })).toBe(false)
+    expect(isRetryableCloudTasks({ code: 'already_exists' })).toBe(false)
+  })
+
+  test('treats UNAVAILABLE (code: 14) as retryable', () => {
+    expect(isRetryableCloudTasks({ code: 14 })).toBe(true)
+    expect(isRetryableCloudTasks({ grpcCode: 14 })).toBe(true)
+  })
+
+  test('treats HTTP 5xx and 429 as retryable, 4xx not retryable', () => {
+    expect(isRetryableCloudTasks({ response: { status: 500 } })).toBe(true)
+    expect(isRetryableCloudTasks({ response: { status: 503 } })).toBe(true)
+    expect(isRetryableCloudTasks({ response: { status: 429 } })).toBe(true)
+
+    expect(isRetryableCloudTasks({ response: { status: 400 } })).toBe(false)
+    expect(isRetryableCloudTasks({ response: { status: 404 } })).toBe(false)
+  })
+
+  test('treats node network errno like ECONNRESET as retryable (delegated to isRetryableDefault)', () => {
+    // isRetryableDefault recognizes typical node syscodes like 'ECONNRESET'
+    expect(isRetryableCloudTasks({ code: 'ECONNRESET' })).toBe(true)
+    expect(isRetryableCloudTasks({ code: 'ETIMEDOUT' })).toBe(true)
+    expect(isRetryableCloudTasks({ code: 'EAI_AGAIN' })).toBe(true)
+  })
+
+  test('plain Error without hints is not retryable', () => {
+    expect(isRetryableCloudTasks(new Error('oops'))).toBe(false)
+  })
+
+  test('non-standard objects without response but with message may or may not be retryable depending on heuristics', () => {
+    // This test documents the expected behavior: a message-only error generally is NOT retryable
+    // unless the message contains a retryable substring (e.g. "timeout" or "unavailable").
+    expect(isRetryableCloudTasks({ message: 'socket closed' })).toBe(false)
+    expect(isRetryableCloudTasks({ message: 'request timed out' })).toBe(true)
+    expect(isRetryableCloudTasks({ message: 'temporarily unavailable' })).toBe(true)
+  })
+})
+
+describe('createTask (with retry)', () => {
+  const projectId = 'test-project'
+  const region = 'us-central1'
+  const queueId = 'test-queue'
+  const data = { test: 'data' }
+  const serviceAccount = 'test-sa@test.iam.gserviceaccount.com'
+  const audience = 'https://run-url'
+  const mockTaskName =
+    'projects/test-project/locations/us-central1/queues/test-queue/tasks/task-123'
+
+  let warnSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    mockCreateTask.mockReset()
+    mockQueuePath.mockClear()
+    mockRetry.mockReset()
+    // store the spy instance so we can assert against it safely
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  it('throws error if any required parameter is missing', async () => {
+    // Ensure retry / createTask are not called for parameter validation errors
+    await expect(
+      createTask('', 'region', 'queue', {}, 'serviceAccount', 'audience')
+    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
+
+    await expect(
+      createTask('project', '', 'queue', {}, 'serviceAccount', 'audience')
+    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
+
+    await expect(
+      createTask('project', 'region', '', {}, 'serviceAccount', 'audience')
+    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
+
+    await expect(createTask('project', 'region', 'queue', {}, '', 'audience')).rejects.toThrow(
+      'Missing required parameters for Cloud Tasks setup'
+    )
+
+    await expect(
+      createTask('project', 'region', 'queue', {}, 'serviceAccount', '')
+    ).rejects.toThrow('Missing required parameters for Cloud Tasks setup')
+
+    expect(mockCreateTask).not.toHaveBeenCalled()
+    expect(mockRetry).not.toHaveBeenCalled()
+  })
+
+  it('should create a task and return task name (calls retry once)', async () => {
+    // Configure retry mock to simply execute the provided function immediately.
+    mockRetry.mockImplementation(async (fn: () => any) => {
+      return await fn()
+    })
+
+    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+
+    expect(result).toBe(mockTaskName)
+    expect(mockCreateTask).toHaveBeenCalledTimes(1)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+    // ensure the createTask was called with an object containing `task`
+    const calledArg = mockCreateTask.mock.calls[0][0]
+    expect(calledArg).toHaveProperty('task')
+  })
+
+  it('should throw error if task name is missing', async () => {
+    mockRetry.mockImplementation(async (fn: () => any) => {
+      return await fn()
+    })
+    mockCreateTask.mockResolvedValue([{}]) // Simulate missing name
+
+    await expect(
+      createTask(projectId, region, queueId, { foo: 'bar' }, serviceAccount, audience)
+    ).rejects.toThrow('Failed to create task: no name returned')
+  })
+
+  it('should include scheduleTime if delaySeconds is set', async () => {
+    mockRetry.mockImplementation(async (fn: () => any) => await fn())
+    mockCreateTask.mockResolvedValue([
+      { name: 'projects/test/locations/us-central1/queues/test/tasks/task-456' }
+    ])
+
+    const delaySeconds = 120
+    const before = Math.floor(Date.now() / 1000) + delaySeconds
+
+    await createTask(
+      projectId,
+      region,
+      queueId,
+      { message: 'delayed' },
+      serviceAccount,
+      audience,
+      delaySeconds
+    )
+
+    const taskArg = mockCreateTask.mock.calls[0][0].task
+    const scheduleTime = taskArg.scheduleTime?.seconds
+
+    const after = Math.floor(Date.now() / 1000) + delaySeconds
+
+    expect(typeof scheduleTime).toBe('number')
+    expect(scheduleTime).toBeGreaterThanOrEqual(before)
+    expect(scheduleTime).toBeLessThanOrEqual(after)
+  })
+
+  it('retries on transient (UNAVAILABLE) error then succeeds', async () => {
+    // Simulate createTask: first call rejects with transient code 14, second call resolves.
+    mockCreateTask
+      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' })
+      .mockResolvedValueOnce([{ name: mockTaskName }])
+
+    // Implement a small retry simulator: call fn(); if it throws then call opts.onRetry and call fn() again.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch (err) {
+        // simulate onRetry callback being invoked by retry implementation
+        if (opts?.onRetry) {
+          try {
+            opts.onRetry(err, 1, 0)
+          } catch {
+            // ignore
+          }
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+    expect(result).toBe(mockTaskName)
+  })
+
+  it('returns expected name if ALREADY_EXISTS and taskId provided (idempotent)', async () => {
+    // Simulate retry throwing ALREADY_EXISTS error (code: 6)
+    mockRetry.mockImplementation(async () => {
+      throw { code: 6, message: 'ALREADY_EXISTS' }
+    })
+
+    const taskId = 'task-123'
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/${taskId}`
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience, 0, {
+      taskId
+    })
+
+    // Should return expected name when ALREADY_EXISTS and taskId provided
+    expect(result).toBe(expectedName)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes an isRetryable to retry that treats ALREADY_EXISTS as non-retryable and UNAVAILABLE as retryable', async () => {
+    // Spy on the options passed to retry and invoke isRetryable with sample errors
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      // Sanity: opts should exist and include isRetryable
+      expect(opts).toBeDefined()
+      expect(typeof opts.isRetryable).toBe('function')
+
+      const isRetryable = opts.isRetryable
+
+      // ALREADY_EXISTS (gRPC code 6) should NOT be retryable
+      expect(isRetryable({ code: 6 })).toBe(false)
+      // UNAVAILABLE (gRPC code 14) should be retryable
+      expect(isRetryable({ code: 14 })).toBe(true)
+
+      expect(isRetryable({ code: 'ECONNRESET' })).toBe(true)
+
+      // Execute the function normally for this test
+      return await fn()
+    })
+
+    mockCreateTask.mockResolvedValue([{ name: mockTaskName }])
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(mockTaskName)
+    expect(mockRetry).toHaveBeenCalledTimes(1)
+  })
+
+  it('invokes onRetry with actual error message and logs it', async () => {
+    // first call fails with a retryable transient error, second call succeeds
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/1`
+    mockCreateTask
+      .mockRejectedValueOnce({ code: 14, message: 'UNAVAILABLE' }) // transient
+      .mockResolvedValueOnce([{ name: expectedName }])
+
+    // Simulate retry behaviour: call fn(); if it throws, call onRetry(err, attempt, delay) then try fn() again.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch (err) {
+        if (opts?.onRetry) {
+          opts.onRetry(err, 1, 0)
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(expectedName)
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+
+    // assert onRetry logged the attempt and included the error message
+    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+    const warnMsg = warnSpy.mock.calls[0][0] as string
+    expect(warnMsg).toContain('createTask retry #1 in 0ms')
+    expect(warnMsg).toContain('UNAVAILABLE')
+  })
+
+  it('invokes onRetry with undefined error and logs "undefined" in message', async () => {
+    const expectedName = `projects/${projectId}/locations/${region}/queues/${queueId}/tasks/2`
+    mockCreateTask
+      .mockRejectedValueOnce(new Error('boom')) // this will trigger catch in our mockRetry
+      .mockResolvedValueOnce([{ name: expectedName }])
+
+    // This variant calls onRetry(undefined, ...) to exercise the err?.message ?? err branch.
+    mockRetry.mockImplementation(async (fn: () => any, opts?: any) => {
+      try {
+        return await fn()
+      } catch {
+        if (opts?.onRetry) {
+          opts.onRetry(undefined, 1, 0) // pass undefined as the error
+        }
+        return await fn()
+      }
+    })
+
+    const result = await createTask(projectId, region, queueId, data, serviceAccount, audience)
+    expect(result).toBe(expectedName)
+    expect(mockCreateTask).toHaveBeenCalledTimes(2)
+
+    // Assert the onRetry prefix was logged
+    expect(warnSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+    const warnMsg = warnSpy.mock.calls[0][0] as string
+    expect(warnMsg).toContain('createTask retry #1 in 0ms')
+
+    // instead of requiring the exact 'undefined' substring (which can vary),
+    // assert there's something logged in the error slot (non-empty)
+    const afterPrefix = warnMsg.replace('createTask retry #1 in 0ms — ', '')
+    expect(afterPrefix.length).toBeGreaterThan(0)
+  })
+})