@tstdl/base 0.93.140 → 0.93.142

package/task-queue/tests/complex.test.js

@@ -1,306 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { currentTimestamp } from '../../utils/date-time.js';
-import { timeout } from '../../utils/timing.js';
-describe('Complex Queue Scenarios', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `complex-queue-${Date.now()}-${Math.random()}`;
-        // Configure with specific settings for testing logic
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-            priorityAgingInterval: 50, // Fast aging
-            priorityAgingStep: 10,
-            rateLimit: 5,
-            rateInterval: 200,
-            retryDelayMinimum: 50,
-            retryDelayGrowth: 2,
-            retention: 50, // Fast retention for archive test
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        await queueProvider.get('other-queue').clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 50; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status === status)
-                return;
-            await queue.processPendingFanIn();
-            await timeout(10);
-        }
-    }
-    describe('Complex Dependencies', () => {
-        it('should handle Diamond Dependency (A -> B, A -> C, (B&C) -> D)', async () => {
-            // D waits for B and C
-            const taskD = await queue.enqueue('D', {}, { scheduleAfterTags: ['tag-b', 'tag-c'] });
-            // B and C wait for A
-            const taskB = await queue.enqueue('B', {}, { tags: ['tag-b'], scheduleAfterTags: ['tag-a'] });
-            const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-a'] });
-            // A runs first
-            const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
-            expect(taskD.status).toBe(TaskStatus.Waiting);
-            expect(taskB.status).toBe(TaskStatus.Waiting);
-            expect(taskC.status).toBe(TaskStatus.Waiting);
-            expect(taskA.status).toBe(TaskStatus.Pending);
-            // Process A
-            const dA = await queue.dequeue({ types: ['A'] });
-            await queue.complete(dA);
-            await waitForStatus(taskB.id, TaskStatus.Pending);
-            await waitForStatus(taskC.id, TaskStatus.Pending);
-            // Process B
-            const dB = await queue.dequeue({ types: ['B'] });
-            await queue.complete(dB);
-            await timeout(20);
-            await queue.processPendingFanIn();
-            // D still waiting (needs C)
-            const uD2 = await queue.getTask(taskD.id);
-            expect(uD2?.status).toBe(TaskStatus.Waiting);
-            // Process C
-            const dC = await queue.dequeue({ types: ['C'] });
-            await queue.complete(dC);
-            await waitForStatus(taskD.id, TaskStatus.Pending);
-            // D should be Pending
-            const uD3 = await queue.getTask(taskD.id);
-            expect(uD3?.status).toBe(TaskStatus.Pending);
-        });
-        it('should handle Deep Chain (A -> B -> C -> D)', async () => {
-            const D = await queue.enqueue('D', {}, { scheduleAfterTags: ['C'] });
-            const C = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'] });
-            const B = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
-            const A = await queue.enqueue('A', {}, { tags: ['A'] });
-            // Run A
-            await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(B.id, TaskStatus.Pending);
-            // Run B
-            await queue.complete((await queue.dequeue({ types: ['B'] })));
-            await waitForStatus(C.id, TaskStatus.Pending);
-            // Run C
-            await queue.complete((await queue.dequeue({ types: ['C'] })));
-            await waitForStatus(D.id, TaskStatus.Pending);
-            expect((await queue.getTask(D.id))?.status).toBe(TaskStatus.Pending);
-        });
-        it('should propagate cancellation down the dependency tree', async () => {
-            // Use parentId for explicit tree structure which `cancel` supports
-            const root = await queue.enqueue('root', {});
-            const child = await queue.enqueue('child', {}, { parentId: root.id });
-            const grandChild = await queue.enqueue('grand', {}, { parentId: child.id });
-            await queue.cancel(root.id);
-            expect((await queue.getTask(root.id))?.status).toBe(TaskStatus.Cancelled);
-            expect((await queue.getTask(child.id))?.status).toBe(TaskStatus.Cancelled);
-            expect((await queue.getTask(grandChild.id))?.status).toBe(TaskStatus.Cancelled);
-        });
-    });
-    describe('Scheduling & Priorities', () => {
-        it('should promote priority of old pending tasks (Aging)', async () => {
-            const t1 = await queue.enqueue('low', {}, { priority: 2000 });
-            // Wait for aging interval (50ms)
-            await timeout(60);
-            await queue.maintenance();
-            const updated = await queue.getTask(t1.id);
-            // Default step is 10. 2000 - 10 = 1990
-            expect(updated?.priority).toBe(1990);
-        });
-        it('should respect exponential backoff on failure', async () => {
-            const task = await queue.enqueue('fail-test', {});
-            // Try 1
-            const d1 = await queue.dequeue();
-            await queue.fail(d1, new Error('fail 1'));
-            const u1 = await queue.getTask(task.id);
-            expect(u1?.tries).toBe(1);
-            const delay1 = u1.scheduleTimestamp - currentTimestamp();
-            expect(delay1).toBeGreaterThan(20); // Approx check
-            // Force reschedule to now
-            await queue.reschedule(task.id, currentTimestamp());
-            // Try 2
-            const d2 = await queue.dequeue();
-            await queue.fail(d2, new Error('fail 2'));
-            const u2 = await queue.getTask(task.id);
-            expect(u2?.tries).toBe(2);
-            const now = currentTimestamp();
-            expect(u2.scheduleTimestamp > now + 50).toBe(true);
-        });
-    });
-    describe('Rate Limiting & Concurrency', () => {
-        it('should limit burst dequeue rate', async () => {
-            // Rate limit 5, interval 100ms
-            await queue.enqueueMany(Array.from({ length: 10 }, (_, i) => ({ type: 'burst', data: { i } })));
-            // Request burstCapacity (5)
-            const batch1 = await queue.dequeueMany(5);
-            expect(batch1.length).toBe(5);
-            // Try immediately again
-            const batch2 = await queue.dequeueMany(1);
-            expect(batch2.length).toBe(0); // Rate limited
-            // Wait for refill
-            await timeout(300);
-            const batch3 = await queue.dequeueMany(5);
-            expect(batch3.length).toBe(5); // Refilled
-        });
-        it('should respect global concurrency limit', async () => {
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const limitQueue = queueProvider.get(`limit-${Date.now()}`, { globalConcurrency: 2 });
-            await limitQueue.enqueueMany([
-                { type: 'c', data: {} },
-                { type: 'c', data: {} },
-                { type: 'c', data: {} },
-            ]);
-            const t1 = await limitQueue.dequeue();
-            const t2 = await limitQueue.dequeue();
-            const t3 = await limitQueue.dequeue();
-            expect(t1).toBeDefined();
-            expect(t2).toBeDefined();
-            expect(t3).toBeUndefined(); // Max concurrency reached
-            await limitQueue.complete(t1);
-            const t3_retry = await limitQueue.dequeue();
-            expect(t3_retry).toBeDefined();
-            await limitQueue.clear();
-        });
-    });
-    describe('Archival & Maintenance', () => {
-        it('should archive completed tasks after retention period', async () => {
-            const qProvider = injector.resolve(TaskQueueProvider);
-            const archiveQueue = qProvider.get(`archive-${Date.now()}-${Math.random()}`, { retention: 100 });
-            const task = await archiveQueue.enqueue('archive-me', {});
-            const d = await archiveQueue.dequeue();
-            await archiveQueue.complete(d);
-            // Verify it is in main table
-            const before = await archiveQueue.getTask(task.id);
-            expect(before).toBeDefined();
-            expect(before?.status).toBe(TaskStatus.Completed);
-            expect(before.completeTimestamp > 0).toBe(true);
-            // Wait for retention (50ms).
-            await timeout(60);
-            await archiveQueue.maintenance();
-            // Should move from main table to archive
-            const loaded = await archiveQueue.getTask(task.id);
-            expect(loaded).toBeDefined();
-            expect(loaded?.status).toBe(TaskStatus.Completed);
-            await archiveQueue.clear();
-        });
-        it('should prune expired pending tasks', async () => {
-            // Time to live: 50ms
-            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 50 });
-            await timeout(60);
-            await queue.maintenance();
-            const updated = await queue.getTask(task.id);
-            expect(updated?.status).toBe(TaskStatus.Dead);
-            expect((updated?.error)['code']).toBe('Expired');
-        });
-        it('should retrieve task from archive', async () => {
-            // Manually insert into archive? We can't access archiveRepository directly.
-            // But we can use maintenance to force it.
-            // Wait, if the previous test failed, this might also fail.
-            // But let's try with a VERY clear scenario.
-            const task = await queue.enqueue('archive-retrieval-test', {});
-            const d = await queue.dequeue();
-            await queue.complete(d);
-            // Force move
-            await timeout(60);
-            await queue.maintenance();
-            // Verify retrieval
-            const fromArchive = await queue.getTask(task.id);
-            expect(fromArchive).toBeDefined();
-            expect(fromArchive?.status).toBe(TaskStatus.Completed);
-        });
-        it('should defer archival of parent tasks until children are archived', async () => {
-            const qProvider = injector.resolve(TaskQueueProvider);
-            const treeQueue = qProvider.get(`archive-tree-${Date.now()}`, { retention: 50 });
-            const parent = await treeQueue.enqueue('parent', {});
-            const child = await treeQueue.enqueue('child', {}, { parentId: parent.id });
-            const d1 = await treeQueue.dequeue();
-            const d2 = await treeQueue.dequeue();
-            await treeQueue.complete(d1);
-            await treeQueue.complete(d2);
-            // Wait for retention
-            await timeout(60);
-            // First maintenance: should archive child, but parent stays because child is still in main table (until it's deleted in the same tx maybe? No, loadMany happens before delete)
-            await treeQueue.maintenance();
-            const parentStillActive = await treeQueue.getTask(parent.id);
-            const childInArchive = await treeQueue.getTask(child.id);
-            // Verify child moved
-            expect(childInArchive).toBeDefined();
-            // Parent MUST still be in main table because child was present when archival query ran
-            expect(parentStillActive).toBeDefined();
-            // Second maintenance: should now archive parent because child is gone from main table
-            await treeQueue.maintenance();
-            const finalParent = await treeQueue.getTask(parent.id);
-            expect(finalParent).toBeDefined(); // Still defined (getTask checks both main and archive)
-            // We need to check if it's REALLY archived.
-            // We can use the #repository directly if we were in the class, but here we can check if it moved by checking against the main table?
-            // Actually getTask is implemented as:
-            /*
-            const active = await this.#repository.tryLoadByQuery({ namespace: this.#namespace, id });
-            if (isDefined(active)) return active;
-            return await this.#archiveRepository.tryLoadByQuery({ namespace: this.#namespace, id });
-            */
-            await treeQueue.clear();
-        });
-    });
-    describe('Batch & Bulk Operations', () => {
-        it('should enqueue and dequeue large batches', async () => {
-            const items = Array.from({ length: 50 }, (_, i) => ({ type: 'bulk', data: { i } }));
-            const queueProvider = injector.resolve(TaskQueueProvider);
-            const bulkQueue = queueProvider.get(`bulk-${Date.now()}`, { rateLimit: 100 });
-            await bulkQueue.enqueueMany(items);
-            const count = await bulkQueue.countByTags([]); // All -> 0 because empty intersection
-            expect(count).toBe(0);
-            const batch = await bulkQueue.dequeueMany(50);
-            expect(batch.length).toBe(50);
-            await bulkQueue.completeMany(batch);
-            await bulkQueue.clear();
-        });
-        it('should handle idempotency window', async () => {
-            const key = 'idem-test';
-            const t1 = await queue.enqueue('t', { v: 1 }, { idempotencyKey: key });
-            const t2 = await queue.enqueue('t', { v: 2 }, { idempotencyKey: key });
-            expect(t1.id).toBe(t2.id); // Deduplicated
-            const t3 = await queue.enqueue('t', { v: 3 }, { idempotencyKey: key, replace: true });
-            expect(t3.id).not.toBe(t1.id); // Replaced
-            expect(t3.data['v']).toBe(3);
-        });
-    });
-    describe('Edge Cases', () => {
-        it('should not fan-in if dependency fails and failFast=false', async () => {
-            const dependent = await queue.enqueue('dep', {}, { scheduleAfterTags: ['fail-tag'], failFast: false });
-            const prereq = await queue.enqueue('pre', {}, { tags: ['fail-tag'] });
-            const d = await queue.dequeue({ types: ['pre'] });
-            await queue.fail(d, new Error('fail'));
-            await queue.processPendingFanIn();
-            // Retry check because fan-in might be processed by background worker asynchronously
-            let u = await queue.getTask(dependent.id);
-            for (let i = 0; i < 5; i++) {
-                if (u?.status == TaskStatus.Waiting)
-                    break;
-                await timeout(10);
-                u = await queue.getTask(dependent.id);
-            }
-            expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete
-        });
-        it('should handle mixed AND/OR dependencies', async () => {
-            const dep = await queue.enqueue('dep', {}, {
-                scheduleAfterTags: ['A', 'B'],
-                dependencyJoinMode: DependencyJoinMode.Or,
-            });
-            const A = await queue.enqueue('A', {}, { tags: ['A'] });
-            await queue.complete((await queue.dequeue({ types: ['A'] })));
-            await waitForStatus(dep.id, TaskStatus.Pending);
-            expect((await queue.getTask(dep.id))?.status).toBe(TaskStatus.Pending);
-        });
-        it('should not reschedule if task is not running', async () => {
-            const task = await queue.enqueue('t', {});
-            const res = await queue.touch(task);
-            expect(res).toBeUndefined();
-        });
-    });
-});

package/task-queue/tests/extensive-dependencies.test.js

@@ -1,234 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
-import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { timeout } from '../../utils/timing.js';
-describe('Extensive Task Queue Dependency Tests', () => {
-    let injector;
-    let queue;
-    beforeAll(async () => {
-        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
-    });
-    beforeEach(() => {
-        const queueProvider = injector.resolve(TaskQueueProvider);
-        const queueName = `extensive-dep-queue-${Date.now()}-${Math.random()}`;
-        queue = queueProvider.get(queueName, {
-            visibilityTimeout: 1000,
-        });
-    });
-    afterEach(async () => {
-        await queue.clear();
-    });
-    afterAll(async () => {
-        await injector?.dispose();
-    });
-    async function waitForStatus(id, status) {
-        for (let i = 0; i < 100; i++) {
-            const task = await queue.getTask(id);
-            if (task?.status === status)
-                return;
-            await queue.processPendingFanIn();
-            await timeout(50);
-        }
-        const finalTask = await queue.getTask(id);
-        throw new Error(`Task ${id} did not reach status ${status}. Current status: ${finalTask?.status}`);
-    }
-    async function completeTask(type) {
-        const dequeued = await queue.dequeue({ types: [type] });
-        if (!dequeued)
-            throw new Error(`Could not dequeue task of type ${type}`);
-        await queue.complete(dequeued);
-        await queue.processPendingFanIn();
-    }
-    it('should handle complex mixed chain: A -> (B -> D, C -> E) -> F', async () => {
-        // F depends on D and E
-        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['mc-d', 'mc-e'] });
-        // D depends on B, E depends on C
-        const taskD = await queue.enqueue('D', {}, { tags: ['mc-d'], scheduleAfterTags: ['mc-b'] });
-        const taskE = await queue.enqueue('E', {}, { tags: ['mc-e'], scheduleAfterTags: ['mc-c'] });
-        // B and C depend on A
-        const taskB = await queue.enqueue('B', {}, { tags: ['mc-b'], scheduleAfterTags: ['mc-a'] });
-        const taskC = await queue.enqueue('C', {}, { tags: ['mc-c'], scheduleAfterTags: ['mc-a'] });
-        // A is the root
-        const taskA = await queue.enqueue('A', {}, { tags: ['mc-a'] });
-        expect(taskA.status).toBe(TaskStatus.Pending);
-        expect(taskB.status).toBe(TaskStatus.Waiting);
-        expect(taskC.status).toBe(TaskStatus.Waiting);
-        expect(taskD.status).toBe(TaskStatus.Waiting);
-        expect(taskE.status).toBe(TaskStatus.Waiting);
-        expect(taskF.status).toBe(TaskStatus.Waiting);
-        // 1. Complete A
-        await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
-        await waitForStatus(taskC.id, TaskStatus.Pending);
-        // 2. Complete B
-        await completeTask('B');
-        await waitForStatus(taskD.id, TaskStatus.Pending);
-        // 3. Complete C
-        await completeTask('C');
-        await waitForStatus(taskE.id, TaskStatus.Pending);
-        // F should still be waiting
-        const uF = await queue.getTask(taskF.id);
-        expect(uF?.status).toBe(TaskStatus.Waiting);
-        // 4. Complete D
-        await completeTask('D');
-        // F still waiting for E
-        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
-        // 5. Complete E
-        await completeTask('E');
-        await waitForStatus(taskF.id, TaskStatus.Pending);
-    });
-    it('should handle requested pattern: A -> B & C -> D', async () => {
-        const taskD = await queue.enqueue('D', {}, { scheduleAfterTags: ['B', 'C'] });
-        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
-        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['A'] });
-        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
-        // Initial check
-        expect(taskA.status).toBe(TaskStatus.Pending);
-        expect(taskB.status).toBe(TaskStatus.Waiting);
-        expect(taskC.status).toBe(TaskStatus.Waiting);
-        expect(taskD.status).toBe(TaskStatus.Waiting);
-        // Complete A
-        await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
-        await waitForStatus(taskC.id, TaskStatus.Pending);
-        // B and C can be dequeued now (in any order)
-        const dB = await queue.dequeue({ types: ['B'] });
-        const dC = await queue.dequeue({ types: ['C'] });
-        expect(dB).toBeDefined();
-        expect(dC).toBeDefined();
-        // D still waiting
-        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
-        // Complete B
-        await queue.complete(dB);
-        await queue.processPendingFanIn();
-        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
-        // Complete C
-        await queue.complete(dC);
-        await waitForStatus(taskD.id, TaskStatus.Pending);
-    });
-    it('should strictly adhere to order: A -> B -> C', async () => {
-        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'] });
-        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
-        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
-        // Try to dequeue B and C - should fail
-        const dC = await queue.dequeue({ types: ['C'] });
-        const dB = await queue.dequeue({ types: ['B'] });
-        expect(dC).toBeUndefined();
-        expect(dB).toBeUndefined();
-        // Complete A
-        const dA = await queue.dequeue({ types: ['A'] });
-        expect(dA?.id).toBe(taskA.id);
-        await queue.complete(dA);
-        await queue.processPendingFanIn();
-        // Now B should be available, but C still not
-        const dC_2 = await queue.dequeue({ types: ['C'] });
-        expect(dC_2).toBeUndefined();
-        const dB_2 = await queue.dequeue({ types: ['B'] });
-        expect(dB_2?.id).toBe(taskB.id);
-        await queue.complete(dB_2);
-        await queue.processPendingFanIn();
-        // Now C should be available
-        const dC_3 = await queue.dequeue({ types: ['C'] });
-        expect(dC_3?.id).toBe(taskC.id);
-        await queue.complete(dC_3);
-    });
-    it('should handle large fan-in: (T1, T2, T3, T4, T5) -> Result', async () => {
-        const tags = ['t1', 't2', 't3', 't4', 't5'];
-        const taskResult = await queue.enqueue('Result', {}, { scheduleAfterTags: tags });
-        for (const tag of tags) {
-            await queue.enqueue(`Task-${tag}`, {}, { tags: [tag] });
-        }
-        // Complete all but one
-        for (let i = 0; i < 4; i++) {
-            await completeTask(`Task-${tags[i]}`);
-            expect((await queue.getTask(taskResult.id))?.status).toBe(TaskStatus.Waiting);
-        }
-        // Complete the last one
-        await completeTask(`Task-${tags[4]}`);
-        await waitForStatus(taskResult.id, TaskStatus.Pending);
-    });
-    it('should handle large fan-in with OR: (T1, T2, T3, T4, T5) -> Result', async () => {
-        const tags = ['o1', 'o2', 'o3', 'o4', 'o5'];
-        const taskResult = await queue.enqueue('Result', {}, {
-            scheduleAfterTags: tags,
-            dependencyJoinMode: DependencyJoinMode.Or
-        });
-        for (const tag of tags) {
-            await queue.enqueue(`Task-${tag}`, {}, { tags: [tag] });
-        }
-        // Complete one
-        await completeTask(`Task-${tags[2]}`);
-        await waitForStatus(taskResult.id, TaskStatus.Pending);
-    });
-    it('should handle Diamond of Diamonds: A -> (B1, B2) -> C -> (D1, D2) -> E', async () => {
-        const taskE = await queue.enqueue('E', {}, { scheduleAfterTags: ['tag-d1', 'tag-d2'] });
-        const taskD1 = await queue.enqueue('D1', {}, { tags: ['tag-d1'], scheduleAfterTags: ['tag-c'] });
-        const taskD2 = await queue.enqueue('D2', {}, { tags: ['tag-d2'], scheduleAfterTags: ['tag-c'] });
-        const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-b1', 'tag-b2'] });
-        const taskB1 = await queue.enqueue('B1', {}, { tags: ['tag-b1'], scheduleAfterTags: ['tag-a'] });
-        const taskB2 = await queue.enqueue('B2', {}, { tags: ['tag-b2'], scheduleAfterTags: ['tag-a'] });
-        const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
-        // Step by step completion
-        await completeTask('A');
-        await waitForStatus(taskB1.id, TaskStatus.Pending);
-        await waitForStatus(taskB2.id, TaskStatus.Pending);
-        await completeTask('B1');
-        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('B2');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
-        await completeTask('C');
-        await waitForStatus(taskD1.id, TaskStatus.Pending);
-        await waitForStatus(taskD2.id, TaskStatus.Pending);
-        await completeTask('D1');
-        expect((await queue.getTask(taskE.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('D2');
-        await waitForStatus(taskE.id, TaskStatus.Pending);
-    });
-    it('should fail-fast entire branch if one dependency fails fatal', async () => {
-        // A -> B -> C
-        //   -> D -> E
-        // (C & E) -> F
-        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['C', 'E'], failFast: true });
-        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'], failFast: true });
-        const taskE = await queue.enqueue('E', {}, { tags: ['E'], scheduleAfterTags: ['D'], failFast: true });
-        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'], failFast: true });
-        const taskD = await queue.enqueue('D', {}, { tags: ['D'], scheduleAfterTags: ['A'], failFast: true });
-        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
-        await completeTask('A');
-        await waitForStatus(taskB.id, TaskStatus.Pending);
-        await waitForStatus(taskD.id, TaskStatus.Pending);
-        // Fail B fatally
-        const dB = await queue.dequeue({ types: ['B'] });
-        await queue.fail(dB, new Error('fatal B'), { fatal: true });
-        await queue.processPendingFanIn();
-        // B failed fatally -> C should die -> F should die
-        await waitForStatus(taskC.id, TaskStatus.Dead);
-        await waitForStatus(taskF.id, TaskStatus.Dead);
-        // D and E should be unaffected (except E is still waiting for D)
-        const uD = await queue.getTask(taskD.id);
-        expect(uD?.status).toBe(TaskStatus.Pending);
-    });
-    it('should handle many-to-many dependencies', async () => {
-        // {A, B} -> {C, D} -> {E, F}
-        // Each of C, D depends on BOTH A and B.
-        // Each of E, F depends on BOTH C and D.
-        const taskE = await queue.enqueue('E', {}, { scheduleAfterTags: ['C', 'D'] });
-        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['C', 'D'] });
-        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['A', 'B'] });
-        const taskD = await queue.enqueue('D', {}, { tags: ['D'], scheduleAfterTags: ['A', 'B'] });
-        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
-        const taskB = await queue.enqueue('B', {}, { tags: ['B'] });
-        await completeTask('A');
-        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
-        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('B');
-        await waitForStatus(taskC.id, TaskStatus.Pending);
-        await waitForStatus(taskD.id, TaskStatus.Pending);
-        await completeTask('C');
-        expect((await queue.getTask(taskE.id))?.status).toBe(TaskStatus.Waiting);
-        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
-        await completeTask('D');
-        await waitForStatus(taskE.id, TaskStatus.Pending);
-        await waitForStatus(taskF.id, TaskStatus.Pending);
-    });
-});