fix: type errors in tests

Author: muniter

src/interfaces/job.ts

@@ -1,4 +1,4 @@
-export type JobStatus = 'waiting' | 'delayed' | 'reserved' | 'done';
+export type JobStatus = 'waiting' | 'delayed' | 'reserved' | 'done' | 'failed';
 
 export interface JobMeta {
   ttr?: number;

tests/core/queue.test.ts

@@ -1,17 +1,17 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { Queue } from '../../src/core/queue.ts';
-import { JobMeta, QueueMessage } from '../../src/interfaces/job.ts';
+import type { JobMeta, QueueMessage, DbJobRequest } from '../../src/interfaces/job.ts';
 
 interface TestJobs {
   'test-job': { data: string };
   'math-job': { a: number; b: number };
 }
 
-class TestQueue extends Queue<TestJobs> {
-  public messages: Array<{ payload: Buffer; meta: JobMeta; id: string }> = [];
+class TestQueue extends Queue<TestJobs, DbJobRequest<any>> {
+  public messages: Array<{ payload: string; meta: JobMeta; id: string }> = [];
   private nextId = 1;
 
-  protected async pushMessage(payload: Buffer, meta: JobMeta): Promise<string> {
+  protected async pushMessage(payload: string, meta: JobMeta): Promise<string> {
     const id = this.nextId.toString();
     this.nextId++;
     this.messages.push({ payload, meta, id });
@@ -53,9 +53,9 @@ describe('Queue', () => {
 
       expect(id).toBe('1');
       expect(queue.messages).toHaveLength(1);
-      expect(queue.messages[0].meta.ttr).toBe(300);
-      expect(queue.messages[0].meta.delay).toBe(0);
-      expect(queue.messages[0].meta.priority).toBe(0);
+      expect(queue.messages[0]?.meta.ttr).toBe(300);
+      expect(queue.messages[0]?.meta.delay).toBe(0);
+      expect(queue.messages[0]?.meta.priority).toBe(0);
     });
 
     it('should add a job with custom settings using new API', async () => {
@@ -68,9 +68,9 @@ describe('Queue', () => {
 
       expect(id).toBe('1');
       expect(queue.messages).toHaveLength(1);
-      expect(queue.messages[0].meta.ttr).toBe(600);
-      expect(queue.messages[0].meta.delay).toBe(30);
-      expect(queue.messages[0].meta.priority).toBe(5);
+      expect(queue.messages[0]?.meta.ttr).toBe(600);
+      expect(queue.messages[0]?.meta.delay).toBe(30);
+      expect(queue.messages[0]?.meta.priority).toBe(5);
     });
 
     it('should emit beforePush and afterPush events', async () => {
@@ -98,8 +98,8 @@ describe('Queue', () => {
       await queue.addJob('test-job', { payload: { data: 'job1' }, ttr: 600 });
       await queue.addJob('test-job', { payload: { data: 'job2' } });
 
-      expect(queue.messages[0].meta.ttr).toBe(600);
-      expect(queue.messages[1].meta.ttr).toBe(300); // back to default
+      expect(queue.messages[0]?.meta.ttr).toBe(600);
+      expect(queue.messages[1]?.meta.ttr).toBe(300); // back to default
     });
   });
 
@@ -108,14 +108,14 @@ describe('Queue', () => {
       const handlerSpy = vi.fn().mockResolvedValue(undefined);
       queue.onJob('test-job', handlerSpy);
 
-      const payload = Buffer.from(JSON.stringify({
+      const payloadString = JSON.stringify({
         name: 'test-job',
         payload: { data: 'test data' }
-      }));
+      });
 
       const message: QueueMessage = {
         id: '1',
-        payload,
+        payload: payloadString,
         meta: { ttr: 300 }
       };
 
@@ -134,14 +134,14 @@ describe('Queue', () => {
       queue.on('afterExec', afterExecSpy);
       queue.onJob('test-job', handlerSpy);
 
-      const payload = Buffer.from(JSON.stringify({
+      const payloadString = JSON.stringify({
         name: 'test-job',
         payload: { data: 'test data' }
-      }));
+      });
 
       const message: QueueMessage = {
         id: '1',
-        payload,
+        payload: payloadString,
         meta: { ttr: 300 }
       };
 
@@ -168,14 +168,14 @@ describe('Queue', () => {
       queue.onJob('test-job', handlerSpy);
       queue.on('afterError', errorSpy);
 
-      const payload = Buffer.from(JSON.stringify({
+      const payloadString = JSON.stringify({
         name: 'test-job',
         payload: { data: 'test data' }
-      }));
+      });
 
       const message: QueueMessage = {
         id: '1',
-        payload,
+        payload: payloadString,
         meta: { ttr: 300 }
       };
 
@@ -197,14 +197,14 @@ describe('Queue', () => {
       const errorSpy = vi.fn();
       queue.on('afterError', errorSpy);
 
-      const payload = Buffer.from(JSON.stringify({
+      const payloadString = JSON.stringify({
         name: 'unregistered-job',
         payload: { data: 'test data' }
-      }));
+      });
 
       const message: QueueMessage = {
         id: '1',
-        payload,
+        payload: payloadString,
         meta: { ttr: 300 }
       };
 

tests/drivers/db-real.test.ts

@@ -90,11 +90,11 @@ describe('DbQueue with Real SQLite Adapter', () => {
       const jobs = db.prepare('SELECT * FROM jobs').all();
       expect(jobs).toHaveLength(1);
 
-      const job = jobs[0];
-      expect(job.status).toBe('waiting');
+      const job = jobs[0] as any;
+      expect(job?.status).toBe('waiting');
 
       // Verify the payload contains our data (it's a serialized job request)
-      const payloadStr = job.payload.toString();
+      const payloadStr = job?.payload?.toString();
       expect(payloadStr).toContain('persistent');
     });
 
@@ -110,8 +110,8 @@ describe('DbQueue with Real SQLite Adapter', () => {
       expect(new Set(jobs).size).toBe(3); // All IDs should be unique
 
       // Verify all jobs are in database
-      const jobCount = db.prepare('SELECT COUNT(*) as count FROM jobs').get();
-      expect(jobCount.count).toBe(3);
+      const jobCount = db.prepare('SELECT COUNT(*) as count FROM jobs').get() as any;
+      expect(jobCount?.count).toBe(3);
     });
 
     it('should properly handle database transactions', async () => {
@@ -180,8 +180,8 @@ describe('DbQueue with Real SQLite Adapter', () => {
       const insertTime = Date.now() - startTime;
 
       // Verify all jobs were inserted
-      const count = db.prepare('SELECT COUNT(*) as count FROM jobs').get();
-      expect(count.count).toBe(jobCount);
+      const count = db.prepare('SELECT COUNT(*) as count FROM jobs').get() as any;
+      expect(count?.count).toBe(jobCount);
 
       // Should be reasonably fast (less than 1 second for 100 jobs)
       expect(insertTime).toBeLessThan(1000);

tests/drivers/db.test.ts

@@ -36,7 +36,7 @@ describe('DbQueue', () => {
       expect(immediateReserve).toBeNull();
 
       // In a real test, we'd wait or mock time
-      expect(dbAdapter.jobsArray[0].meta.delay).toBe(5);
+      expect(dbAdapter.jobsArray[0]?.meta.delay).toBe(5);
     });
 
     it('should handle job execution lifecycle', async () => {
@@ -90,7 +90,7 @@ describe('DbQueue', () => {
       expect(await queue.status(id)).toBe('reserved');
 
       // After completing
-      await queue['release']({ id, payload: Buffer.from(''), meta: {} });
+      await queue['release']({ id, payload: '', meta: {} });
       expect(await queue.status(id)).toBe('done');
     });
   });

tests/drivers/sqs.test.ts

@@ -35,8 +35,8 @@ describe('SqsQueue', () => {
 
       expect(sqsClient.sentMessages).toHaveLength(1);
       const sentMessage = sqsClient.sentMessages[0];
-      expect(sentMessage.MessageAttributes?.ttr?.StringValue).toBe('600');
-      expect(sentMessage.DelaySeconds).toBe(30);
+      expect(sentMessage?.MessageAttributes?.ttr?.StringValue).toBe('600');
+      expect(sentMessage?.DelaySeconds).toBe(30);
     });
 
     it('should respect delay seconds', async () => {
@@ -47,7 +47,7 @@ describe('SqsQueue', () => {
 
       expect(sqsClient.sentMessages).toHaveLength(1);
       const message = sqsClient.sentMessages[0];
-      expect(message.DelaySeconds).toBe(30);
+      expect(message?.DelaySeconds).toBe(30);
     });
 
     it('should handle job processing', async () => {

tests/integration/mongodb-debug.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
 import { MongoClient, ObjectId } from 'mongodb';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
+import { GenericContainer, type StartedTestContainer } from 'testcontainers';
 import { MongoQueue, createMongoQueue, MongoDatabaseAdapter } from '../../src/adapters/mongodb.ts';
 
 interface TestJobs {
@@ -62,8 +62,8 @@ describe.only('MongoDB Debug Tests', () => {
     expect(jobs).toHaveLength(1);
 
     const job = jobs[0];
-    expect(job.status).toBe('waiting');
-    expect(job.payload).toBeTruthy();
+    expect(job?.status).toBe('waiting');
+    expect(job?.payload).toBeTruthy();
 
     console.log('=== STEP 3: Checking job status ===');
     const status = await queue.status(jobId);

tests/integration/mongodb.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
 import { MongoClient, ObjectId } from 'mongodb';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
+import { GenericContainer, type StartedTestContainer } from 'testcontainers';
 import { MongoQueue, createMongoQueue, createMongoQueueFromUrl, MongoDatabaseAdapter } from '../../src/adapters/mongodb.ts';
 
 interface TestJobs {
@@ -67,12 +67,16 @@ describe('MongoDB Integration Tests (with TestContainers)', () => {
       // Add a job to trigger index creation
       await queue.addJob('simple-job', { payload: { data: 'test' } });
 
+      // Wait a bit for async index creation to complete
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
       // Check that indexes exist
       const db = client.db(testDatabase);
       const collection = db.collection(testCollection);
       const indexes = await collection.listIndexes().toArray();
 
-      expect(indexes.length).toBeGreaterThan(1); // Should have more than just the default _id index
+      // Should have the default _id index plus our custom indexes (at least 2 total)
+      expect(indexes.length).toBeGreaterThanOrEqual(2);
     });
   });
 

tests/integration/redis.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';
 import { createClient } from 'redis';
-import { GenericContainer, StartedTestContainer } from 'testcontainers';
+import { GenericContainer, type StartedTestContainer } from 'testcontainers';
 import { RedisQueue, createRedisQueue, RedisDatabaseAdapter } from '../../src/adapters/redis.ts';
 
 interface TestJobs {

tests/integration/sqlite.test.ts

@@ -86,9 +86,9 @@ describe('SQLite Integration Tests', () => {
       expect(await queue.status(id)).toBe('waiting');
 
       // Verify job is stored in database
-      const job = db.prepare('SELECT * FROM jobs WHERE id = ?').get(parseInt(id));
+      const job = db.prepare('SELECT * FROM jobs WHERE id = ?').get(parseInt(id)) as any;
       expect(job).toBeTruthy();
-      expect(job.status).toBe('waiting');
+      expect(job?.status).toBe('waiting');
     });
 
     it('should handle job delays correctly', async () => {
@@ -170,8 +170,8 @@ describe('SQLite Integration Tests', () => {
       });
 
       // Verify TTR is stored correctly
-      const job = db.prepare('SELECT * FROM jobs WHERE id = ?').get(parseInt(id));
-      expect(job.ttr).toBe(10);
+      const job = db.prepare('SELECT * FROM jobs WHERE id = ?').get(parseInt(id)) as any;
+      expect(job?.ttr).toBe(10);
     });
   });
 

tests/jobs/test-job.ts

@@ -1,42 +1,19 @@
-import { Job, Queue } from '../../src/index.ts';
+import type { Queue } from '../../src/index.ts';
 
-export class SimpleJob implements Job<string> {
-  constructor(public data: string) {}
+// Simple test job handler functions (not classes)
+export const simpleJobHandler = async (payload: { data: string }): Promise<string> => {
+  return `Processed: ${payload.data}`;
+};
 
-  async execute(queue: Queue): Promise<string> {
-    return `Processed: ${this.data}`;
+export const failingJobHandler = async (payload: { shouldFail?: boolean }): Promise<void> => {
+  if (payload.shouldFail !== false) {
+    throw new Error('Job intentionally failed');
   }
+};
 
-  serialize() {
-    return {
-      constructor: 'SimpleJob',
-      data: this.data
-    };
-  }
-
-  static deserialize(data: any): SimpleJob {
-    return new SimpleJob(data.data);
-  }
-}
-
-export class FailingJob implements Job<void> {
-  constructor(public shouldFail: boolean = true) {}
-
-  async execute(queue: Queue): Promise<void> {
-    if (this.shouldFail) {
-      throw new Error('Job intentionally failed');
-    }
-  }
-
-  serialize() {
-    return {
-      constructor: 'FailingJob',
-      shouldFail: this.shouldFail
-    };
-  }
-
-  static deserialize(data: any): FailingJob {
-    return new FailingJob(data.shouldFail);
-  }
+// Test job types for type safety
+export interface TestJobs {
+  'simple-job': { data: string };
+  'failing-job': { shouldFail?: boolean };
 }