@nicnocquee/dataqueue 1.22.0 → 1.25.0

package/src/processor.test.ts

@@ -6,8 +6,9 @@ import {
   processJobWithHandlers,
 } from './processor.js';
 import * as queue from './queue.js';
+import { PostgresBackend } from './backends/postgres.js';
 import { createTestDbAndPool, destroyTestDb } from './test-util.js';
-import { FailureReason, JobHandler } from './types.js';
+import { FailureReason, JobHandler, JobContext } from './types.js';
 
 // Define the payload map for test jobs
 interface TestPayloadMap {
@@ -21,16 +22,29 @@ interface TestPayloadMap {
   typeC: { n: number };
 }
 
+/**
+ * Claims a job by transitioning it to 'processing' status (simulates getNextBatch).
+ * Tests that call processJobWithHandlers directly need the job in 'processing' state.
+ */
+async function claimJob(p: Pool, jobId: number) {
+  await p.query(
+    `UPDATE job_queue SET status = 'processing', locked_by = 'test-worker', locked_at = NOW() WHERE id = $1`,
+    [jobId],
+  );
+}
+
 // Integration tests for processor
 
 describe('processor integration', () => {
   let pool: Pool;
   let dbName: string;
+  let backend: PostgresBackend;
 
   beforeEach(async () => {
     const setup = await createTestDbAndPool();
     pool = setup.pool;
     dbName = setup.dbName;
+    backend = new PostgresBackend(pool);
   });
 
   afterEach(async () => {
@@ -54,12 +68,17 @@ describe('processor integration', () => {
       jobType: 'test',
       payload: { foo: 'bar' },
     });
-    const job = await queue.getJob<TestPayloadMap, 'test'>(pool, jobId);
+    // Claim the job so it's in 'processing' status
+    const [job] = await queue.getNextBatch(pool, 'test-worker', 1);
     expect(job).not.toBeNull();
-    await processJobWithHandlers(pool, job!, handlers);
+    await processJobWithHandlers(backend, job!, handlers);
     expect(handler).toHaveBeenCalledWith(
       { foo: 'bar' },
       expect.any(AbortSignal),
+      expect.objectContaining({
+        prolong: expect.any(Function),
+        onTimeout: expect.any(Function),
+      }),
     );
     const completed = await queue.getJob(pool, jobId);
     expect(completed?.status).toBe('completed');
@@ -83,9 +102,10 @@ describe('processor integration', () => {
       jobType: 'fail',
       payload: {},
     });
+    await claimJob(pool, jobId);
     const job = await queue.getJob<TestPayloadMap, 'fail'>(pool, jobId);
     expect(job).not.toBeNull();
-    await processJobWithHandlers(pool, job!, handlers);
+    await processJobWithHandlers(backend, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
     expect(failed?.errorHistory?.[0]?.message).toBe('fail!');
@@ -109,10 +129,11 @@ describe('processor integration', () => {
       jobType: 'missing',
       payload: {},
     });
+    await claimJob(pool, jobId);
     const job = await queue.getJob<TestPayloadMap, 'missing'>(pool, jobId);
     expect(job).not.toBeNull();
     // @ts-expect-error - test handler is missing
-    await processJobWithHandlers(pool, job!, handlers);
+    await processJobWithHandlers(backend, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
     expect(failed?.errorHistory?.[0]?.message).toContain(
@@ -144,7 +165,7 @@ describe('processor integration', () => {
       }),
     ]);
     const processed = await processBatchWithHandlers(
-      pool,
+      backend,
       'worker-batch',
       2,
       undefined,
@@ -175,7 +196,7 @@ describe('processor integration', () => {
       jobType: 'proc',
       payload: { x: 1 },
     });
-    const processor = createProcessor(pool, handlers, { pollInterval: 200 });
+    const processor = createProcessor(backend, handlers, { pollInterval: 200 });
     processor.start();
     // Wait for job to be processed
     await new Promise((r) => setTimeout(r, 500));
@@ -212,7 +233,7 @@ describe('processor integration', () => {
     });
     // Only process typeA
     const processed = await processBatchWithHandlers(
-      pool,
+      backend,
       'worker-typeA',
       10,
       'typeA',
@@ -259,7 +280,7 @@ describe('processor integration', () => {
     });
     // Only process typeA and typeC
     const processed = await processBatchWithHandlers(
-      pool,
+      backend,
       'worker-multi',
       10,
       ['typeA', 'typeC'],
@@ -300,7 +321,7 @@ describe('processor integration', () => {
       jobType: 'typeB',
       payload: { n: 2 },
     });
-    const processor = createProcessor(pool, handlers, {
+    const processor = createProcessor(backend, handlers, {
       pollInterval: 100,
       jobType: 'typeA',
     });
@@ -320,11 +341,13 @@ describe('processor integration', () => {
 describe('concurrency option', () => {
   let pool: Pool;
   let dbName: string;
+  let backend: PostgresBackend;
 
   beforeEach(async () => {
     const setup = await createTestDbAndPool();
     pool = setup.pool;
     dbName = setup.dbName;
+    backend = new PostgresBackend(pool);
   });
 
   afterEach(async () => {
@@ -352,7 +375,7 @@ describe('concurrency option', () => {
     };
     const handlers = { test: handler };
     await addJobs(10);
-    const processor = createProcessor(pool, handlers, { batchSize: 10 });
+    const processor = createProcessor(backend, handlers, { batchSize: 10 });
     await processor.start();
     expect(maxParallel).toBeLessThanOrEqual(3);
   });
@@ -368,7 +391,7 @@ describe('concurrency option', () => {
     };
     const handlers = { test: handler };
     await addJobs(10);
-    const processor = createProcessor(pool, handlers, {
+    const processor = createProcessor(backend, handlers, {
       batchSize: 10,
       concurrency: 2,
     });
@@ -387,7 +410,7 @@ describe('concurrency option', () => {
     };
     const handlers = { test: handler };
     await addJobs(2);
-    const processor = createProcessor(pool, handlers, {
+    const processor = createProcessor(backend, handlers, {
       batchSize: 2,
       concurrency: 5,
     });
@@ -406,7 +429,7 @@ describe('concurrency option', () => {
     };
     const handlers = { test: handler };
     await addJobs(5);
-    const processor = createProcessor(pool, handlers, {
+    const processor = createProcessor(backend, handlers, {
       batchSize: 5,
       concurrency: 1,
     });
@@ -418,11 +441,13 @@ describe('concurrency option', () => {
 describe('per-job timeout', () => {
   let pool: Pool;
   let dbName: string;
+  let backend: PostgresBackend;
 
   beforeEach(async () => {
     const setup = await createTestDbAndPool();
     pool = setup.pool;
     dbName = setup.dbName;
+    backend = new PostgresBackend(pool);
   });
 
   afterEach(async () => {
@@ -448,9 +473,10 @@ describe('per-job timeout', () => {
       payload: {},
       timeoutMs: 50, // 50ms
     });
+    await claimJob(pool, jobId);
     const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
     expect(job).not.toBeNull();
-    await processJobWithHandlers(pool, job!, handlers);
+    await processJobWithHandlers(backend, job!, handlers);
     const failed = await queue.getJob(pool, jobId);
     expect(failed?.status).toBe('failed');
     expect(failed?.errorHistory?.[0]?.message).toContain('timed out');
@@ -469,10 +495,580 @@ describe('per-job timeout', () => {
       payload: {},
       timeoutMs: 200, // 200ms
     });
+    await claimJob(pool, jobId);
     const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
     expect(job).not.toBeNull();
-    await processJobWithHandlers(pool, job!, handlers);
+    await processJobWithHandlers(backend, job!, handlers);
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+  });
+
+  it('should forcefully terminate job when forceKillOnTimeout is true', async () => {
+    // Create a handler that ignores the abort signal (simulating a handler that doesn't check signal.aborted)
+    // Note: We use a real function (not vi.fn) because vi.fn doesn't serialize properly for worker threads
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+    ) => {
+      // This handler will run indefinitely, ignoring the abort signal
+      await new Promise((resolve) => {
+        setTimeout(resolve, 1000); // Will never complete in time
+      });
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50, // 50ms timeout
+      forceKillOnTimeout: true, // Force kill on timeout
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+    expect(job).not.toBeNull();
+    expect(job?.forceKillOnTimeout).toBe(true);
+    await processJobWithHandlers(backend, job!, handlers);
+    const failed = await queue.getJob(pool, jobId);
+    expect(failed?.status).toBe('failed');
+    expect(failed?.errorHistory?.[0]?.message).toContain('timed out');
+    expect(failed?.failureReason).toBe(FailureReason.Timeout);
+  });
+
+  it('should complete job with forceKillOnTimeout if handler finishes before timeout', async () => {
+    // Note: We use a real function (not vi.fn) because vi.fn doesn't serialize properly for worker threads
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+    ) => {
+      await new Promise((r) => setTimeout(r, 20));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 200, // 200ms
+      forceKillOnTimeout: true,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+    expect(job).not.toBeNull();
+    await processJobWithHandlers(backend, job!, handlers);
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+  });
+});
+
+describe('prolong', () => {
+  let pool: Pool;
+  let dbName: string;
+  let backend: PostgresBackend;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+    backend = new PostgresBackend(pool);
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should extend timeout when prolong is called with explicit duration', async () => {
+    // Setup
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      // Wait 60ms, but initial timeout is 50ms -- would fail without prolong
+      await new Promise((r) => setTimeout(r, 30));
+      ctx.prolong(100); // extend to 100ms from now
+      await new Promise((r) => setTimeout(r, 60));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+  });
+
+  it('should extend timeout when prolong is called without arguments (heartbeat)', async () => {
+    // Setup
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      // Initial timeout is 80ms, total work ~120ms
+      await new Promise((r) => setTimeout(r, 50));
+      ctx.prolong(); // reset to original 80ms from now
+      await new Promise((r) => setTimeout(r, 60));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 80,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
     const completed = await queue.getJob(pool, jobId);
     expect(completed?.status).toBe('completed');
   });
+
+  it('should still timeout if prolong is not called', async () => {
+    // Setup
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      signal,
+    ) => {
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, 200);
+        signal.addEventListener('abort', () => {
+          clearTimeout(t);
+          reject(new Error('aborted'));
+        });
+      });
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const failed = await queue.getJob(pool, jobId);
+    expect(failed?.status).toBe('failed');
+    expect(failed?.failureReason).toBe(FailureReason.Timeout);
+  });
+
+  it('should be a no-op when job has no timeout', async () => {
+    // Setup
+    let ctxReceived: JobContext | undefined;
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      ctxReceived = ctx;
+      ctx.prolong(1000); // should be a no-op
+      await new Promise((r) => setTimeout(r, 20));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      // no timeoutMs
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+    expect(ctxReceived).toBeDefined();
+    expect(ctxReceived!.prolong).toBeTypeOf('function');
+  });
+
+  it('should update locked_at in the database when prolong is called', async () => {
+    // Setup
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      await new Promise((r) => setTimeout(r, 30));
+      ctx.prolong(200);
+      // Give DB time to update (fire-and-forget)
+      await new Promise((r) => setTimeout(r, 50));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 100,
+    });
+    const jobBefore = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+    // Pick up the job so it gets locked_at set
+    const batch = await queue.getNextBatch<{ test: {} }, 'test'>(
+      pool,
+      'test-worker',
+      1,
+    );
+    const lockedAtBefore = batch[0]!.lockedAt;
+
+    // Act
+    await processJobWithHandlers(backend, batch[0]!, handlers);
+
+    // Assert - check that a prolonged event was recorded
+    const events = await queue.getJobEvents(pool, jobId);
+    const prolongedEvents = events.filter((e) => e.eventType === 'prolonged');
+    expect(prolongedEvents.length).toBeGreaterThanOrEqual(1);
+  });
+});
+
+describe('onTimeout', () => {
+  let pool: Pool;
+  let dbName: string;
+  let backend: PostgresBackend;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+    backend = new PostgresBackend(pool);
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should extend timeout reactively when onTimeout callback returns a positive number', async () => {
+    // Setup
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      ctx.onTimeout(() => {
+        return 100; // extend by 100ms
+      });
+      // Total work: ~80ms, initial timeout 50ms -- would fail without onTimeout extension
+      await new Promise((r) => setTimeout(r, 80));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+  });
+
+  it('should let timeout proceed when onTimeout callback returns nothing', async () => {
+    // Setup
+    const onTimeoutCalled = vi.fn();
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      signal,
+      ctx,
+    ) => {
+      ctx.onTimeout(() => {
+        onTimeoutCalled();
+        // Return nothing -- let timeout proceed
+      });
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, 200);
+        signal.addEventListener('abort', () => {
+          clearTimeout(t);
+          reject(new Error('aborted'));
+        });
+      });
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const failed = await queue.getJob(pool, jobId);
+    expect(failed?.status).toBe('failed');
+    expect(failed?.failureReason).toBe(FailureReason.Timeout);
+    expect(onTimeoutCalled).toHaveBeenCalledTimes(1);
+  });
+
+  it('should allow repeated extensions via onTimeout', async () => {
+    // Setup
+    let callCount = 0;
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      ctx.onTimeout(() => {
+        callCount++;
+        if (callCount <= 3) {
+          return 40; // extend by 40ms each time
+        }
+        // After 3 extensions, let it complete (job should be done by then)
+      });
+      // Total work: ~130ms, initial timeout 40ms
+      // Will need ~3 extensions of 40ms each
+      await new Promise((r) => setTimeout(r, 130));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 40,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+    expect(callCount).toBeGreaterThanOrEqual(2);
+  });
+
+  it('should allow onTimeout with progress-based logic', async () => {
+    // Setup
+    let progress = 0;
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      ctx.onTimeout(() => {
+        if (progress < 100) {
+          return 60; // still working, extend
+        }
+        // done, let timeout proceed if it fires again
+      });
+      // Simulate progress
+      for (let i = 0; i < 5; i++) {
+        await new Promise((r) => setTimeout(r, 25));
+        progress += 20;
+      }
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+    expect(progress).toBe(100);
+  });
+
+  it('should work when both prolong and onTimeout are used together', async () => {
+    // Setup
+    let onTimeoutCalled = false;
+    const handler: JobHandler<{ test: {} }, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      // Register reactive fallback
+      ctx.onTimeout(() => {
+        onTimeoutCalled = true;
+        return 100;
+      });
+      // Proactively extend before timeout hits
+      await new Promise((r) => setTimeout(r, 30));
+      ctx.prolong(100);
+      await new Promise((r) => setTimeout(r, 60));
+    };
+    const handlers: { test: JobHandler<{ test: {} }, 'test'> } = {
+      test: handler,
+    };
+    const jobId = await queue.addJob<{ test: {} }, 'test'>(pool, {
+      jobType: 'test',
+      payload: {},
+      timeoutMs: 50,
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<{ test: {} }, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+    // onTimeout should NOT have been called since prolong extended before timeout fired
+    expect(onTimeoutCalled).toBe(false);
+  });
+
+  it('should persist progress via ctx.setProgress', async () => {
+    // Setup
+    const handler: JobHandler<TestPayloadMap, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      await ctx.setProgress(25);
+      await ctx.setProgress(50);
+      await ctx.setProgress(100);
+    };
+    const handlers = {
+      test: handler,
+      fail: vi.fn(async () => {}),
+      missing: vi.fn(async () => {}),
+      batch: vi.fn(async () => {}),
+      proc: vi.fn(async () => {}),
+      typeA: vi.fn(async () => {}),
+      typeB: vi.fn(async () => {}),
+      typeC: vi.fn(async () => {}),
+    };
+    const jobId = await queue.addJob<TestPayloadMap, 'test'>(pool, {
+      jobType: 'test',
+      payload: { foo: 'bar' },
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<TestPayloadMap, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.status).toBe('completed');
+    expect(completed?.progress).toBe(100);
+  });
+
+  it('should reject progress values outside 0-100', async () => {
+    expect.assertions(2);
+
+    // Setup
+    const handler: JobHandler<TestPayloadMap, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      try {
+        await ctx.setProgress(-1);
+      } catch (err) {
+        expect((err as Error).message).toBe(
+          'Progress must be between 0 and 100',
+        );
+      }
+      try {
+        await ctx.setProgress(101);
+      } catch (err) {
+        expect((err as Error).message).toBe(
+          'Progress must be between 0 and 100',
+        );
+      }
+    };
+    const handlers = {
+      test: handler,
+      fail: vi.fn(async () => {}),
+      missing: vi.fn(async () => {}),
+      batch: vi.fn(async () => {}),
+      proc: vi.fn(async () => {}),
+      typeA: vi.fn(async () => {}),
+      typeB: vi.fn(async () => {}),
+      typeC: vi.fn(async () => {}),
+    };
+    const jobId = await queue.addJob<TestPayloadMap, 'test'>(pool, {
+      jobType: 'test',
+      payload: { foo: 'bar' },
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<TestPayloadMap, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+  });
+
+  it('should round fractional progress values', async () => {
+    // Setup
+    const handler: JobHandler<TestPayloadMap, 'test'> = async (
+      _payload,
+      _signal,
+      ctx,
+    ) => {
+      await ctx.setProgress(33.7);
+    };
+    const handlers = {
+      test: handler,
+      fail: vi.fn(async () => {}),
+      missing: vi.fn(async () => {}),
+      batch: vi.fn(async () => {}),
+      proc: vi.fn(async () => {}),
+      typeA: vi.fn(async () => {}),
+      typeB: vi.fn(async () => {}),
+      typeC: vi.fn(async () => {}),
+    };
+    const jobId = await queue.addJob<TestPayloadMap, 'test'>(pool, {
+      jobType: 'test',
+      payload: { foo: 'bar' },
+    });
+    await claimJob(pool, jobId);
+    const job = await queue.getJob<TestPayloadMap, 'test'>(pool, jobId);
+
+    // Act
+    await processJobWithHandlers(backend, job!, handlers);
+
+    // Assert
+    const completed = await queue.getJob(pool, jobId);
+    expect(completed?.progress).toBe(34);
+  });
 });