@tstdl/base 0.93.126 → 0.93.128

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -1,27 +1,20 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { setupIntegrationTest } from '../../../testing/index.js';
 import { readBinaryStream } from '../../../utils/stream/stream-reader.js';
-import { configureS3ObjectStorage } from '../s3.object-storage-provider.js';
+import { isUndefined } from '../../../utils/type-guards.js';
 import { S3ObjectStorage } from '../s3.object-storage.js';
 describe('S3ObjectStorage Integration', () => {
     let storage;
-    const bucketName = 'integration-test-bucket';
     beforeAll(async () => {
         const { injector } = await setupIntegrationTest({
             modules: { objectStorage: true },
         });
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: bucketName,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
-        });
         storage = await injector.resolveAsync(S3ObjectStorage, 'test-module');
     });
     afterAll(async () => {
+        if (isUndefined(storage)) {
+            return;
+        }
         const objects = await storage.getObjects();
         for (const obj of objects) {
             await storage.deleteObject(obj.key);
@@ -80,7 +73,7 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000);
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
         expect(await response.text()).toBe('signed download');
@@ -154,15 +147,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(stat.metadata['extra-key']).toBe('extra-value');
     });
     it('should work with bucket per module', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const moduleName = `test-bucket-per-module-${Math.floor(Math.random() * 1000000)}`;
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, moduleName);
@@ -177,7 +163,7 @@ describe('S3ObjectStorage Integration', () => {
         const metadata = { 's3-test': 'true' };
         await storage.uploadObject(key, content, { metadata });
         const obj = await storage.getObject(key);
-        expect(await obj.getResourceUri()).toBe(`s3://integration-test-bucket/test-module/${key}`);
+        expect(await obj.getResourceUri()).toBe(`s3://test-module/${key}`);
         expect(await obj.getContentLength()).toBe(content.length);
         expect(await obj.getMetadata()).toMatchObject(metadata);
         expect(new TextDecoder().decode(await obj.getContent())).toBe('s3 object');
@@ -242,25 +228,22 @@ describe('S3ObjectStorage Integration', () => {
         const key = 'signed-download-expires.txt';
         await storage.uploadObject(key, new TextEncoder().encode('signed download expires'));
         const url = await storage.getDownloadUrl(key, Date.now() + 60000, {
-            'Expires': new Date(Date.now() + 60000).toUTCString(),
+            Expires: new Date(Date.now() + 60000).toUTCString(),
         });
-        expect(url).toContain('http://127.0.0.1:9000');
+        expect(url).toMatch(/http:\/\/(127\.0\.0\.1|localhost):9000/);
         const response = await fetch(url);
         expect(response.status).toBe(200);
     });
     it('should handle Forbidden error in ensureBucketExists with wrong credentials', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'wrong',
-            secretKey: 'wrong',
-            bucket: 'forbidden-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
+            s3: {
+                accessKey: 'wrong',
+                secretKey: 'wrong',
+            },
         });
         try {
-            await injector.resolveAsync(S3ObjectStorage, 'test-module');
+            await injector.resolveAsync(S3ObjectStorage, 'forbidden-bucket');
             expect.fail('Should have thrown');
         }
         catch (error) {
@@ -268,17 +251,10 @@ describe('S3ObjectStorage Integration', () => {
         }
     });
     it('should copy object between different storages', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucket: 'another-bucket',
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
-        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-module');
+        const anotherStorage = await injector.resolveAsync(S3ObjectStorage, 'another-bucket');
         const sourceKey = 'cross-storage-source.txt';
         const destKey = 'cross-storage-dest.txt';
         await storage.uploadObject(sourceKey, new TextEncoder().encode('cross storage content'));
@@ -288,15 +264,8 @@ describe('S3ObjectStorage Integration', () => {
         expect(new TextDecoder().decode(content)).toBe('cross storage content');
     });
     it('should cover ensureBucketExists with region', async () => {
-        const { injector } = await setupIntegrationTest();
-        configureS3ObjectStorage({
-            endpoint: 'http://127.0.0.1:9000',
-            accessKey: 'tstdl-dev',
-            secretKey: 'tstdl-dev',
-            bucketPerModule: true,
-            region: 'us-east-1',
-            forcePathStyle: true,
-            injector,
+        const { injector } = await setupIntegrationTest({
+            modules: { objectStorage: true },
         });
         const perModuleStorage = await injector.resolveAsync(S3ObjectStorage, `region-test-${Math.floor(Math.random() * 1000000)}`);
         await perModuleStorage.ensureBucketExists('us-east-1', { objectLocking: true });

package/orm/tests/repository-expiration.test.js

@@ -51,7 +51,7 @@ describe('ORM Repository Expiration', () => {
     ], TtlEntity.prototype, "name", void 0);
     TtlEntity = __decorate([
         Table('ttl_entities', { schema }),
-        TimeToLive(1000, 'hard') // 1s TTL
+        TimeToLive(100, 'hard') // 100ms TTL
     ], TtlEntity);
     beforeAll(async () => {
         injector = new Injector('Test');
@@ -95,8 +95,8 @@ describe('ORM Repository Expiration', () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(TtlEntity);
             const e1 = await repository.insert(Object.assign(new TtlEntity(), { name: 'Valid' }));
-            // Wait 1.1s for expiration
-            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // Wait 150ms for expiration
+            await new Promise((resolve) => setTimeout(resolve, 150));
             await repository.processExpirations();
             const all = await repository.loadAll({ withDeleted: true });
             expect(all).toHaveLength(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.126",
+  "version": "0.93.128",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -11,7 +11,7 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
         rateLimiter = rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
-            refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
+            refillInterval: 500, // 10 tokens per 500ms -> 1 token per 50ms
         });
     });
     afterAll(async () => {
@@ -30,9 +30,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const resource = 'res-2';
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for 2 tokens (200ms)
-        await timeout(250);
-        expect(await rateLimiter.tryAcquire(resource, 2)).toBe(true);
+        // Wait for 1 token (50ms) + buffer
+        await timeout(75);
+        expect(await rateLimiter.tryAcquire(resource, 1)).toBe(true);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
     });
     it('should refund tokens', async () => {
@@ -55,7 +55,9 @@ describe('PostgresRateLimiter Integration Tests', () => {
         await rateLimiter.tryAcquire(resource, 0);
         const results = await Promise.all(Array.from({ length: 20 }).map(() => rateLimiter.tryAcquire(resource, 1)));
         const successCount = results.filter(Boolean).length;
-        expect(successCount).toBe(10);
+        // We expect 10, but allow up to 12 if tokens refilled during the Promise.all
+        expect(successCount).toBeGreaterThanOrEqual(10);
+        expect(successCount).toBeLessThanOrEqual(12);
     }, 15000);
     it('should always allow zero or negative cost', async () => {
         const resource = 'res-zero';
@@ -72,8 +74,8 @@ describe('PostgresRateLimiter Integration Tests', () => {
         // Drain
         await rateLimiter.tryAcquire(resource, 10);
         expect(await rateLimiter.tryAcquire(resource, 1)).toBe(false);
-        // Wait for full refill (1s) + extra
-        await timeout(1200);
+        // Wait for full refill (500ms) + extra
+        await timeout(600);
         // Should only have 10 tokens
         expect(await rateLimiter.tryAcquire(resource, 10)).toBe(true);
         // Should be empty again immediately

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

@@ -15,13 +15,13 @@ describe('Complex Queue Scenarios', () => {
         // Configure with specific settings for testing logic
         queue = queueProvider.get(queueName, {
             visibilityTimeout: 1000,
-            priorityAgingInterval: 100, // Fast aging
+            priorityAgingInterval: 50, // Fast aging
             priorityAgingStep: 10,
             rateLimit: 5,
-            rateInterval: 500,
-            retryDelayMinimum: 100,
+            rateInterval: 50,
+            retryDelayMinimum: 50,
             retryDelayGrowth: 2,
-            retention: 100, // Fast retention for archive test
+            retention: 50, // Fast retention for archive test
         });
     });
     afterEach(async () => {
@@ -33,12 +33,12 @@ describe('Complex Queue Scenarios', () => {
         await injector?.dispose();
     });
     async function waitForStatus(id, status) {
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             const task = await queue.getTask(id);
             if (task?.status === status)
                 return;
             await queue.processPendingFanIn();
-            await timeout(50);
+            await timeout(10);
         }
     }
     describe('Complex Dependencies', () => {
@@ -62,7 +62,7 @@ describe('Complex Queue Scenarios', () => {
             // Process B
             const dB = await queue.dequeue({ types: ['B'] });
             await queue.complete(dB);
-            await timeout(100);
+            await timeout(20);
             await queue.processPendingFanIn();
             // D still waiting (needs C)
             const uD2 = await queue.getTask(taskD.id);
@@ -105,8 +105,8 @@ describe('Complex Queue Scenarios', () => {
     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 (100ms)
-            await timeout(150);
+            // 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
@@ -120,7 +120,7 @@ describe('Complex Queue Scenarios', () => {
             const u1 = await queue.getTask(task.id);
             expect(u1?.tries).toBe(1);
             const delay1 = u1.scheduleTimestamp - currentTimestamp();
-            expect(delay1).toBeGreaterThan(150); // Approx check
+            expect(delay1).toBeGreaterThan(20); // Approx check
             // Force reschedule to now
             await queue.reschedule(task.id, currentTimestamp());
             // Try 2
@@ -129,12 +129,12 @@ describe('Complex Queue Scenarios', () => {
             const u2 = await queue.getTask(task.id);
             expect(u2?.tries).toBe(2);
             const now = currentTimestamp();
-            expect(u2.scheduleTimestamp > now + 300).toBe(true);
+            expect(u2.scheduleTimestamp > now + 50).toBe(true);
         });
     });
     describe('Rate Limiting & Concurrency', () => {
         it('should limit burst dequeue rate', async () => {
-            // Rate limit 5, interval 500ms
+            // 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);
@@ -143,7 +143,7 @@ describe('Complex Queue Scenarios', () => {
             const batch2 = await queue.dequeueMany(1);
             expect(batch2.length).toBe(0); // Rate limited
             // Wait for refill
-            await timeout(600);
+            await timeout(60);
             const batch3 = await queue.dequeueMany(5);
             expect(batch3.length).toBe(5); // Refilled
         });
@@ -179,8 +179,8 @@ describe('Complex Queue Scenarios', () => {
             expect(before).toBeDefined();
             expect(before?.status).toBe(TaskStatus.Completed);
             expect(before.completeTimestamp > 0).toBe(true);
-            // Wait for retention (100ms).
-            await timeout(500);
+            // Wait for retention (50ms).
+            await timeout(60);
             await archiveQueue.maintenance();
             // Should move from main table to archive
             const loaded = await archiveQueue.getTask(task.id);
@@ -189,9 +189,9 @@ describe('Complex Queue Scenarios', () => {
             await archiveQueue.clear();
         });
         it('should prune expired pending tasks', async () => {
-            // Time to live: 100ms
-            const task = await queue.enqueue('expire-me', {}, { timeToLive: currentTimestamp() + 100 });
-            await timeout(150);
+            // 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);
@@ -206,7 +206,7 @@ describe('Complex Queue Scenarios', () => {
             const d = await queue.dequeue();
             await queue.complete(d);
             // Force move
-            await timeout(200);
+            await timeout(60);
             await queue.maintenance();
             // Verify retrieval
             const fromArchive = await queue.getTask(task.id);
@@ -215,7 +215,7 @@ describe('Complex Queue Scenarios', () => {
         });
         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: 100 });
+            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();
@@ -223,7 +223,7 @@ describe('Complex Queue Scenarios', () => {
             await treeQueue.complete(d1);
             await treeQueue.complete(d2);
             // Wait for retention
-            await timeout(200);
+            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);
@@ -282,7 +282,7 @@ describe('Complex Queue Scenarios', () => {
             for (let i = 0; i < 5; i++) {
                 if (u?.status == TaskStatus.Waiting)
                     break;
-                await timeout(50);
+                await timeout(10);
                 u = await queue.getTask(dependent.id);
             }
             expect(u?.status).toBe(TaskStatus.Waiting); // Should still be waiting because dependency didn't Complete

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

@@ -22,6 +22,16 @@ describe('Queue Dependencies & Tree Tests', () => {
     afterAll(async () => {
         await injector?.dispose();
     });
+    async function waitForStatus(id, status) {
+        for (let i = 0; i < 20; i++) {
+            const task = await queue.getTask(id);
+            if (task?.status == status) {
+                return;
+            }
+            await queue.processPendingFanIn();
+            await timeout(50);
+        }
+    }
     describe('Dependencies (Fan-In)', () => {
         it('should schedule a task only after dependency completes (completeAfterTags)', async () => {
             // 1. Create a dependent task (Waiting)
@@ -35,7 +45,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             expect(dequeued?.id).toBe(prereq.id);
             await queue.complete(dequeued);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Completed);
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Completed);
         });
@@ -50,7 +60,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             // 3. Complete prereq
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             await queue.complete(dequeued);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Pending);
             // 5. Dependent should be Pending (ready to run)
             const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Pending);
@@ -67,16 +77,8 @@ describe('Queue Dependencies & Tree Tests', () => {
             const dequeued = await queue.dequeue({ types: ['prereq'] });
             // Fail fatally
             await queue.fail(dequeued, new Error('boom'), { fatal: true });
-            // Trigger resolution
-            await queue.processPendingFanIn();
-            let updatedDependent;
-            for (let i = 0; i < 20; i++) {
-                await timeout(100);
-                updatedDependent = await queue.getTask(dependent.id);
-                if (updatedDependent?.status === TaskStatus.Dead)
-                    break;
-                await queue.processPendingFanIn(); // Retry processing if it didn't catch it yet
-            }
+            await waitForStatus(dependent.id, TaskStatus.Dead);
+            const updatedDependent = await queue.getTask(dependent.id);
             expect(updatedDependent?.status).toBe(TaskStatus.Dead);
             expect(updatedDependent?.error?.code).toBe('DependencyFailed');
         });
@@ -90,7 +92,7 @@ describe('Queue Dependencies & Tree Tests', () => {
             await queue.enqueue('t1', {}, { tags: ['tag-1'] });
             const d1 = await queue.dequeue({ types: ['t1'] });
             await queue.complete(d1);
-            await queue.processPendingFanIn();
+            await waitForStatus(dependent.id, TaskStatus.Pending);
             const updated = await queue.getTask(dependent.id);
             expect(updated?.status).toBe(TaskStatus.Pending);
         });

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

@@ -134,11 +134,11 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
         const queueName = `pg-test-queue-${Date.now()}-${Math.random()}`;
         queue = queueProvider.get(queueName, {
-            visibilityTimeout: 200, // Short timeout for testing
+            visibilityTimeout: 50, // Short timeout for testing
             retryDelayMinimum: 50,
             retryDelayGrowth: 1,
             circuitBreakerThreshold: 2,
-            circuitBreakerResetTimeout: 200,
+            circuitBreakerResetTimeout: 50,
         });
     });
     afterEach(async () => {
@@ -188,11 +188,11 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             expect((t3?.data)['foo']).toBe('low');
         });
         it('should not dequeue a task scheduled in the future', async () => {
-            const future = currentTimestamp() + 500;
+            const future = currentTimestamp() + 100;
             await queue.enqueue('foo', { foo: 'future' }, { scheduleTimestamp: future });
             const task = await queue.dequeue();
             expect(task).toBeUndefined();
-            await timeout(600);
+            await timeout(150);
             const taskLater = await queue.dequeue();
             expect(taskLater).toBeDefined();
         });
@@ -237,8 +237,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             ]);
             await queue.fail((await queue.dequeue()), 'err');
             await queue.fail((await queue.dequeue()), 'err');
-            // Breaker is Open. Wait for reset timeout (200ms)
-            await timeout(250);
+            // Breaker is Open. Wait for reset timeout (50ms)
+            await timeout(75);
             const probe = await queue.dequeue();
             expect(probe).toBeDefined();
             const secondAttempt = await queue.dequeue();
@@ -249,8 +249,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         it('should recover "Zombie" tasks (crashed workers)', async () => {
             const task = await queue.enqueue('foo', { foo: 'zombie' });
             await queue.dequeue(); // Task is now Running with a token
-            // processTimeout is 200ms. Wait for it to expire.
-            await timeout(300);
+            // processTimeout is 50ms. Wait for it to expire.
+            await timeout(100);
             await queue.maintenance();
             const recovered = await queue.getTask(task.id);
             expect(recovered?.status).toBe(TaskStatus.Pending);
@@ -260,10 +260,10 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
         it('should fail tasks that exceed Hard Execution Timeout via prune', async () => {
             // Re-configure queue with very short execution timeout
             const queueProvider = injector.resolve(TaskQueueProvider);
-            const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { maxExecutionTime: 100 });
+            const shortQueue = queueProvider.get(`prune-test-${Date.now()}`, { maxExecutionTime: 50 });
             const task = await shortQueue.enqueue('foo', { foo: 'long-running' });
             await shortQueue.dequeue();
-            await timeout(200);
+            await timeout(75);
             await shortQueue.maintenance();
             const updated = await shortQueue.getTask(task.id);
             expect(updated?.status).toBe(TaskStatus.Dead);
@@ -274,7 +274,7 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             const task = await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             const initialLock = dequeued.visibilityDeadline;
-            await timeout(50);
+            await timeout(20);
             const touched = await queue.touch(dequeued);
             expect(touched?.visibilityDeadline > initialLock).toBe(true);
         });
@@ -282,8 +282,8 @@ describe('PostgresQueue (Distributed Task Orchestration)', () => {
             await queue.enqueue('foo', { foo: 'work' });
             const dequeued = await queue.dequeue();
             expect(dequeued).toBeDefined();
-            // processTimeout is 200ms. Wait for it to expire.
-            await timeout(300);
+            // processTimeout is 50ms. Wait for it to expire.
+            await timeout(100);
             await queue.maintenance();
             await queue.dequeue(); // Stolen by another worker (tries=2)
             // Original worker tries to touch

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

@@ -14,7 +14,7 @@ describe('Worker & Base Class Tests', () => {
         const queueProvider = injector.resolve(TaskQueueProvider);
         const queueName = `worker-queue-${Date.now()}-${Math.random()}`;
         queue = queueProvider.get(queueName, {
-            visibilityTimeout: 500, // Short visibility for testing lease loss
+            visibilityTimeout: 200, // Short visibility for testing lease loss
         });
         token = new CancellationToken();
     });
@@ -36,10 +36,10 @@ describe('Worker & Base Class Tests', () => {
             return TaskProcessResult.Complete();
         });
         // Wait until 2 tasks are processed
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (processed.length === 2)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set(); // Stop worker
         expect(processed).toContain(1);
@@ -55,7 +55,7 @@ describe('Worker & Base Class Tests', () => {
         queue.process({ cancellationSignal: token }, async () => {
             throw new Error('worker error');
         });
-        await timeout(200);
+        await timeout(50);
         token.set();
         const updated = await queue.getTask(task.id);
         expect(updated?.status).toBe(TaskStatus.Pending); // Should retry
@@ -66,12 +66,12 @@ describe('Worker & Base Class Tests', () => {
         const task = await queue.enqueue('long', {});
         let executed = false;
         queue.process({ cancellationSignal: token }, async (_context) => {
-            // Simulate long work > visibilityTimeout (500ms)
-            await timeout(700);
+            // Simulate long work > visibilityTimeout (200ms)
+            await timeout(300);
             executed = true;
             return TaskProcessResult.Complete();
         });
-        await timeout(1000);
+        await timeout(500);
         token.set();
         expect(executed).toBe(true);
         const updated = await queue.getTask(task.id);
@@ -91,10 +91,10 @@ describe('Worker & Base Class Tests', () => {
             }
             return TaskProcessResult.Complete();
         });
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (processed.size === 2)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         const uFail = await queue.getTask(tFail.id);
@@ -129,10 +129,10 @@ describe('Worker & Base Class Tests', () => {
             executed = true;
             return TaskProcessResult.Complete();
         });
-        for (let i = 0; i < 20; i++) {
+        for (let i = 0; i < 50; i++) {
             if (executed)
                 break;
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         expect(executed).toBe(true);
@@ -159,7 +159,7 @@ describe('Worker & Base Class Tests', () => {
             if (finalAttemptValues.length === 2)
                 break;
             testQueue.notify();
-            await timeout(100);
+            await timeout(20);
         }
         token.set();
         expect(finalAttemptValues).toEqual([false, true]);

package/testing/integration-setup.d.ts

@@ -2,6 +2,7 @@ import type { PoolConfig } from 'pg';
 import { type AuthenticationAncillaryService } from '../authentication/server/index.js';
 import { Injector } from '../injector/index.js';
 import { LogLevel } from '../logger/index.js';
+import { type S3ObjectStorageProviderConfig } from '../object-storage/s3/index.js';
 import { Database } from '../orm/server/index.js';
 import type { Type } from '../types/index.js';
 export type IntegrationTestOptions = {
@@ -13,6 +14,7 @@ export type IntegrationTestOptions = {
         baseUrl?: string;
         port?: number;
     };
+    s3?: Partial<S3ObjectStorageProviderConfig>;
     logLevels?: Record<string, LogLevel>;
     modules?: {
         api?: boolean;

package/testing/integration-setup.js

@@ -98,7 +98,11 @@ export async function setupIntegrationTest(options = {}) {
         }
         if (options.modules?.authentication) {
             configureAuthenticationServer({
-                serviceOptions: { secret: 'test-secret' },
+                serviceOptions: {
+                    secret: 'test-secret',
+                    hashIterations: 10,
+                    signingSecretsDerivationIterations: 10,
+                },
                 authenticationAncillaryService: options.authenticationAncillaryService,
                 injector,
             });
@@ -121,13 +125,15 @@ export async function setupIntegrationTest(options = {}) {
             await runInInjectionContext(injector, migrateDocumentManagementSchema);
         }
         if (options.modules?.objectStorage) {
+            const bucketPerModule = options.s3?.bucketPerModule ?? configParser.boolean('S3_BUCKET_PER_MODULE', true);
             configureS3ObjectStorage({
-                endpoint: configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),
-                accessKey: configParser.string('S3_ACCESS_KEY', 'tstdl-dev'),
-                secretKey: configParser.string('S3_SECRET_KEY', 'tstdl-dev'),
-                bucket: configParser.string('S3_BUCKET', 'test-bucket'),
-                region: configParser.string('S3_REGION', 'us-east-1'),
-                forcePathStyle: configParser.boolean('S3_FORCE_PATH_STYLE', true),
+                endpoint: options.s3?.endpoint ?? configParser.string('S3_ENDPOINT', 'http://127.0.0.1:9000'),
+                accessKey: options.s3?.accessKey ?? configParser.string('S3_ACCESS_KEY', 'tstdl-dev'),
+                secretKey: options.s3?.secretKey ?? configParser.string('S3_SECRET_KEY', 'tstdl-dev'),
+                bucket: bucketPerModule ? undefined : (options.s3?.bucket ?? configParser.string('S3_BUCKET', 'test-bucket')),
+                bucketPerModule,
+                region: options.s3?.region ?? configParser.string('S3_REGION', 'us-east-1'),
+                forcePathStyle: options.s3?.forcePathStyle ?? configParser.boolean('S3_FORCE_PATH_STYLE', true),
                 injector,
             });
         }