@nicnocquee/dataqueue 1.19.3 → 1.21.0

package/src/queue.test.ts

@@ -5,8 +5,6 @@ import { createTestDbAndPool, destroyTestDb } from './test-util.js';
 import { JobEvent, JobEventType } from './types.js';
 import { objectKeysToCamelCase } from './utils.js';
 
-// Example integration test setup
-
 describe('queue integration', () => {
   let pool: Pool;
   let dbName: string;
@@ -501,3 +499,701 @@ describe('job lifecycle timestamp columns', () => {
     expect(job.lastRetriedAt).not.toBeNull();
   });
 });
+
+describe('tags feature', () => {
+  let pool: Pool;
+  let dbName: string;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+  });
+
+  afterEach(async () => {
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should add a job with tags and retrieve it by tags (all mode)', async () => {
+    const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
+      jobType: 'email',
+      payload: { to: 'tagged@example.com' },
+      tags: ['welcome', 'user:1'],
+    });
+    const jobs = await queue.getJobsByTags(pool, ['welcome'], 'all');
+    expect(jobs.map((j) => j.id)).toContain(jobId);
+    expect(jobs[0].tags).toContain('welcome');
+    expect(jobs[0].tags).toContain('user:1');
+  });
+
+  it('should only return jobs that match all specified tags (all mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'a@example.com' },
+        tags: ['foo', 'bar'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'b@example.com' },
+        tags: ['foo'],
+      },
+    );
+
+    const jobId3 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'c@example.com' },
+        tags: ['foo', 'bar', 'baz'],
+      },
+    );
+    const jobs = await queue.getJobsByTags(pool, ['foo', 'bar'], 'all');
+    expect(jobs.map((j) => j.id)).toContain(jobId1);
+    expect(jobs.map((j) => j.id)).not.toContain(jobId2);
+    expect(jobs.map((j) => j.id)).toContain(jobId3);
+  });
+
+  it('should return jobs with exactly the same tags (exact mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'a@example.com' },
+        tags: ['foo', 'bar'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'b@example.com' },
+        tags: ['foo', 'bar', 'baz'],
+      },
+    );
+    const jobs = await queue.getJobsByTags(pool, ['foo', 'bar'], 'exact');
+    expect(jobs.map((j) => j.id)).toContain(jobId1);
+    expect(jobs.map((j) => j.id)).not.toContain(jobId2);
+  });
+
+  it('should return jobs that have any of the given tags (any mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'a@example.com' },
+        tags: ['foo', 'bar'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'b@example.com' },
+        tags: ['baz'],
+      },
+    );
+    const jobs = await queue.getJobsByTags(pool, ['bar', 'baz'], 'any');
+    expect(jobs.map((j) => j.id)).toContain(jobId1);
+    expect(jobs.map((j) => j.id)).toContain(jobId2);
+  });
+
+  it('should return jobs that have none of the given tags (none mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'a@example.com' },
+        tags: ['foo'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'b@example.com' },
+        tags: ['bar'],
+      },
+    );
+    const jobId3 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'c@example.com' },
+        tags: ['baz'],
+      },
+    );
+    const jobs = await queue.getJobsByTags(pool, ['foo', 'bar'], 'none');
+    expect(jobs.map((j) => j.id)).toContain(jobId3);
+    expect(jobs.map((j) => j.id)).not.toContain(jobId1);
+    expect(jobs.map((j) => j.id)).not.toContain(jobId2);
+  });
+
+  it('should handle jobs with no tags', async () => {
+    const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
+      jobType: 'email',
+      payload: { to: 'notag@example.com' },
+    });
+    const jobs = await queue.getJobsByTags(pool, ['anytag'], 'all');
+    expect(jobs.map((j) => j.id)).not.toContain(jobId);
+  });
+
+  it('should cancel jobs by tags (all mode)', async () => {
+    const jobId = await queue.addJob<{ email: { to: string } }, 'email'>(pool, {
+      jobType: 'email',
+      payload: { to: 'cancelme@example.com' },
+      tags: ['cancel', 'urgent'],
+    });
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      tags: { values: ['cancel', 'urgent'], mode: 'all' },
+    });
+    expect(cancelled).toBeGreaterThanOrEqual(1);
+    const job = await queue.getJob(pool, jobId);
+    expect(job?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs by tags (exact mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel1@example.com' },
+        tags: ['cancel', 'urgent'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel2@example.com' },
+        tags: ['cancel', 'urgent', 'other'],
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      tags: { values: ['cancel', 'urgent'], mode: 'exact' },
+    });
+    expect(cancelled).toBe(1);
+    const job1 = await queue.getJob(pool, jobId1);
+    const job2 = await queue.getJob(pool, jobId2);
+    expect(job1?.status).toBe('cancelled');
+    expect(job2?.status).toBe('pending');
+  });
+
+  it('should cancel jobs by tags (any mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel1@example.com' },
+        tags: ['cancel', 'urgent'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel2@example.com' },
+        tags: ['other'],
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      tags: { values: ['cancel', 'other'], mode: 'any' },
+    });
+    expect(cancelled).toBe(2);
+    const job1 = await queue.getJob(pool, jobId1);
+    const job2 = await queue.getJob(pool, jobId2);
+    expect(job1?.status).toBe('cancelled');
+    expect(job2?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs by tags (none mode)', async () => {
+    const jobId1 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel1@example.com' },
+        tags: ['foo'],
+      },
+    );
+    const jobId2 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'cancel2@example.com' },
+        tags: ['bar'],
+      },
+    );
+    const jobId3 = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'keep@example.com' },
+        tags: ['baz'],
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'none' },
+    });
+    expect(cancelled).toBe(1);
+    const job1 = await queue.getJob(pool, jobId1);
+    const job2 = await queue.getJob(pool, jobId2);
+    const job3 = await queue.getJob(pool, jobId3);
+    expect(job1?.status).toBe('pending');
+    expect(job2?.status).toBe('pending');
+    expect(job3?.status).toBe('cancelled');
+  });
+});
+
+describe('cancelAllUpcomingJobs with runAt object filter', () => {
+  let pool: Pool;
+  let dbName: string;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+  });
+
+  afterEach(async () => {
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should cancel jobs with runAt > filter (gt)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { gt: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('pending');
+    expect(jobFuture?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs with runAt >= filter (gte)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { gte: now },
+    });
+    expect(cancelled).toBe(2);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('cancelled');
+  });
+
+  it('should cancel jobs with runAt < filter (lt)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { lt: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('cancelled');
+    expect(jobNow?.status).toBe('pending');
+    expect(jobFuture?.status).toBe('pending');
+  });
+
+  it('should cancel jobs with runAt <= filter (lte)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { lte: now },
+    });
+    expect(cancelled).toBe(2);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('cancelled');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('pending');
+  });
+
+  it('should cancel jobs with runAt eq filter (eq)', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    const cancelled = await queue.cancelAllUpcomingJobs(pool, {
+      runAt: { eq: now },
+    });
+    expect(cancelled).toBe(1);
+    const jobPast = await queue.getJob(pool, jobIdPast);
+    const jobNow = await queue.getJob(pool, jobIdNow);
+    const jobFuture = await queue.getJob(pool, jobIdFuture);
+    expect(jobPast?.status).toBe('pending');
+    expect(jobNow?.status).toBe('cancelled');
+    expect(jobFuture?.status).toBe('pending');
+  });
+});
+
+describe('getJobs', () => {
+  let pool: Pool;
+  let dbName: string;
+
+  beforeEach(async () => {
+    const setup = await createTestDbAndPool();
+    pool = setup.pool;
+    dbName = setup.dbName;
+  });
+
+  afterEach(async () => {
+    await pool.end();
+    await destroyTestDb(dbName);
+  });
+
+  it('should filter by jobType', async () => {
+    const id1 = await queue.addJob<{ a: { n: number }; b: { n: number } }, 'a'>(
+      pool,
+      { jobType: 'a', payload: { n: 1 } },
+    );
+    const id2 = await queue.addJob<{ a: { n: number }; b: { n: number } }, 'b'>(
+      pool,
+      { jobType: 'b', payload: { n: 2 } },
+    );
+    const jobs = await queue.getJobs(pool, { jobType: 'a' });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by priority', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      priority: 1,
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      priority: 2,
+    });
+    const jobs = await queue.getJobs(pool, { priority: 2 });
+    expect(jobs.map((j) => j.id)).toContain(id2);
+    expect(jobs.map((j) => j.id)).not.toContain(id1);
+  });
+
+  it('should filter by runAt', async () => {
+    const runAt = new Date(Date.UTC(2030, 0, 1, 12, 0, 0, 0));
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      runAt,
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+    });
+    const jobs = await queue.getJobs(pool, { runAt });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter jobs using runAt with gt/gte/lt/lte/eq', async () => {
+    const now = new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1000); // 1 day ago
+    const future = new Date(now.getTime() + 24 * 60 * 60 * 1000); // 1 day ahead
+    const jobIdPast = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'past@example.com' },
+        runAt: past,
+      },
+    );
+    const jobIdNow = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'now@example.com' },
+        runAt: now,
+      },
+    );
+    const jobIdFuture = await queue.addJob<{ email: { to: string } }, 'email'>(
+      pool,
+      {
+        jobType: 'email',
+        payload: { to: 'future@example.com' },
+        runAt: future,
+      },
+    );
+    // eq
+    let jobs = await queue.getJobs(pool, { runAt: now });
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+    // gt
+    jobs = await queue.getJobs(pool, { runAt: { gt: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdFuture);
+    expect(jobs.map((j) => j.id)).not.toContain(jobIdNow);
+    // gte
+    jobs = await queue.getJobs(pool, { runAt: { gte: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+    expect(jobs.map((j) => j.id)).toContain(jobIdFuture);
+    // lt
+    jobs = await queue.getJobs(pool, { runAt: { lt: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdPast);
+    expect(jobs.map((j) => j.id)).not.toContain(jobIdNow);
+    // lte
+    jobs = await queue.getJobs(pool, { runAt: { lte: now } });
+    expect(jobs.map((j) => j.id)).toContain(jobIdPast);
+    expect(jobs.map((j) => j.id)).toContain(jobIdNow);
+  });
+
+  it('should filter by tags (all mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['foo'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'all' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by tags (any mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['bar'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'any' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).toContain(id2);
+  });
+
+  it('should filter by tags (exact mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['foo', 'bar', 'baz'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'exact' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should filter by tags (none mode)', async () => {
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      tags: ['foo'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      tags: ['bar'],
+    });
+    const id3 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 3 },
+      tags: ['baz'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      tags: { values: ['foo', 'bar'], mode: 'none' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id3);
+    expect(jobs.map((j) => j.id)).not.toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+
+  it('should support pagination', async () => {
+    const ids = [];
+    for (let i = 0; i < 5; i++) {
+      ids.push(
+        await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+          jobType: 'a',
+          payload: { n: i },
+        }),
+      );
+    }
+    const firstTwo = await queue.getJobs(pool, {}, 2, 0);
+    const nextTwo = await queue.getJobs(pool, {}, 2, 2);
+    expect(firstTwo.length).toBe(2);
+    expect(nextTwo.length).toBe(2);
+    const firstIds = firstTwo.map((j) => j.id);
+    const nextIds = nextTwo.map((j) => j.id);
+    expect(firstIds.some((id) => nextIds.includes(id))).toBe(false);
+  });
+
+  it('should filter by a combination of filters', async () => {
+    const runAt = new Date(Date.UTC(2030, 0, 1, 12, 0, 0, 0));
+    const id1 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 1 },
+      priority: 1,
+      runAt,
+      tags: ['foo', 'bar'],
+    });
+    const id2 = await queue.addJob<{ a: { n: number } }, 'a'>(pool, {
+      jobType: 'a',
+      payload: { n: 2 },
+      priority: 2,
+      tags: ['foo'],
+    });
+    const jobs = await queue.getJobs(pool, {
+      jobType: 'a',
+      priority: 1,
+      runAt,
+      tags: { values: ['foo', 'bar'], mode: 'all' },
+    });
+    expect(jobs.map((j) => j.id)).toContain(id1);
+    expect(jobs.map((j) => j.id)).not.toContain(id2);
+  });
+});