@onebun/core 0.1.10 → 0.1.12

package/src/queue/adapters/memory.adapter.test.ts

@@ -12,6 +12,8 @@ import {
 
 import type { Message } from '../types';
 
+import { useFakeTimers } from '../../testing/test-utils';
+
 import { InMemoryQueueAdapter, createInMemoryQueueAdapter } from './memory.adapter';
 
 describe('InMemoryQueueAdapter', () => {
@@ -114,6 +116,19 @@ describe('InMemoryQueueAdapter', () => {
   });
 
   describe('delayed messages', () => {
+    let advanceTime: (ms: number) => void;
+    let restore: () => void;
+
+    beforeEach(() => {
+      const fakeTimers = useFakeTimers();
+      advanceTime = fakeTimers.advanceTime;
+      restore = fakeTimers.restore;
+    });
+
+    afterEach(() => {
+      restore();
+    });
+
     it('should delay message delivery', async () => {
       await adapter.connect();
 
@@ -127,8 +142,8 @@ describe('InMemoryQueueAdapter', () => {
       // Message should not be received immediately
       expect(received.length).toBe(0);
 
-      // Wait for delay + processing
-      await new Promise((resolve) => setTimeout(resolve, 200));
+      // Advance time past the delay + processing
+      advanceTime(200);
 
       expect(received.length).toBe(1);
       expect(received[0].data).toEqual({ data: 'delayed' });
@@ -250,6 +265,7 @@ describe('InMemoryQueueAdapter', () => {
     });
 
     it('should support nack with requeue', async () => {
+      // This test uses real timers because requeue uses setImmediate internally
       await adapter.connect();
 
       let callCount = 0;
@@ -269,7 +285,7 @@ describe('InMemoryQueueAdapter', () => {
       await adapter.publish('test', { data: 'test' });
 
       // Wait for requeue processing (setImmediate is used for requeue)
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       expect(callCount).toBeGreaterThanOrEqual(2); // Should be called at least twice due to requeue
     });

package/src/queue/adapters/redis.adapter.test.ts

@@ -0,0 +1,289 @@
+/**
+ * Redis Queue Adapter Tests
+ *
+ * Tests using testcontainers for real Redis integration
+ */
+
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+} from 'bun:test';
+import {
+  GenericContainer,
+  type StartedTestContainer,
+  Wait,
+} from 'testcontainers';
+
+import { SharedRedisProvider } from '../../redis/shared-redis';
+
+import { RedisQueueAdapter, createRedisQueueAdapter } from './redis.adapter';
+
+describe('RedisQueueAdapter', () => {
+  let redisContainer: StartedTestContainer;
+  let redisUrl: string;
+  let adapter: RedisQueueAdapter;
+
+  beforeAll(async () => {
+    // Start Redis container
+    redisContainer = await new GenericContainer('redis:7-alpine')
+      .withExposedPorts(6379)
+      .withWaitStrategy(Wait.forLogMessage(/.*Ready to accept connections.*/))
+      .withStartupTimeout(30000)
+      .withLogConsumer(() => {
+        // Suppress container logs
+      })
+      .start();
+
+    const host = redisContainer.getHost();
+    const port = redisContainer.getMappedPort(6379);
+    redisUrl = `redis://${host}:${port}`;
+
+    // Configure shared Redis
+    SharedRedisProvider.configure({ url: redisUrl });
+  });
+
+  afterAll(async () => {
+    await SharedRedisProvider.reset();
+    if (redisContainer) {
+      await redisContainer.stop();
+    }
+  });
+
+  beforeEach(async () => {
+    adapter = createRedisQueueAdapter({
+      useSharedClient: true,
+      keyPrefix: `test:${Date.now()}:`,
+    });
+  });
+
+  afterEach(async () => {
+    if (adapter.isConnected()) {
+      await adapter.disconnect();
+    }
+  });
+
+  describe('lifecycle', () => {
+    it('should create adapter with default options', () => {
+      const defaultAdapter = new RedisQueueAdapter();
+      
+      expect(defaultAdapter.name).toBe('redis');
+      expect(defaultAdapter.type).toBe('redis');
+    });
+
+    it('should create adapter using factory function', () => {
+      const factoryAdapter = createRedisQueueAdapter({
+        keyPrefix: 'factory:',
+      });
+      
+      expect(factoryAdapter).toBeInstanceOf(RedisQueueAdapter);
+    });
+
+    it('should connect successfully', async () => {
+      await adapter.connect();
+      
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should not connect twice', async () => {
+      await adapter.connect();
+      await adapter.connect(); // Should be no-op
+      
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should disconnect successfully', async () => {
+      await adapter.connect();
+      await adapter.disconnect();
+      
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    it('should handle disconnect when not connected', async () => {
+      // Should not throw
+      await adapter.disconnect();
+      
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    it('should emit onReady event on connect', async () => {
+      const onReady = mock(() => undefined);
+      adapter.on('onReady', onReady);
+      
+      await adapter.connect();
+      
+      expect(onReady).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('with own client', () => {
+    it('should create own client when useSharedClient is false', async () => {
+      const ownAdapter = new RedisQueueAdapter({
+        useSharedClient: false,
+        url: redisUrl,
+        keyPrefix: 'own:',
+      });
+
+      await ownAdapter.connect();
+      
+      expect(ownAdapter.isConnected()).toBe(true);
+      
+      await ownAdapter.disconnect();
+    });
+
+    it('should throw when URL missing and not using shared client', async () => {
+      const ownAdapter = new RedisQueueAdapter({
+        useSharedClient: false,
+        // No URL
+      });
+
+      await expect(ownAdapter.connect()).rejects.toThrow(
+        'Redis URL is required',
+      );
+    });
+  });
+
+  // Note: publish/subscribe tests are skipped because the RedisQueueAdapter
+  // relies on RedisClient.raw() method which doesn't work correctly with
+  // Bun's RedisClient API. The raw() method attempts to call Redis commands
+  // as object methods (e.g., client['RPUSH'](...)) but Bun's Redis client
+  // doesn't expose commands this way.
+  //
+  // These tests would need RedisClient.raw() to be fixed to use Bun's
+  // proper command execution API (likely sendCommand or similar).
+  
+  describe('publishing', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should throw when publishing while disconnected', async () => {
+      await adapter.disconnect();
+      
+      await expect(
+        adapter.publish('test:topic', { data: 1 }),
+      ).rejects.toThrow('not connected');
+    });
+  });
+
+  // Note: Delayed and priority message tests are skipped because they require
+  // raw Redis commands (ZADD, ZRANGEBYSCORE) that aren't available through the
+  // current RedisClient.raw() implementation. These features need a proper
+  // implementation using Bun's Redis client's sendCommand API.
+
+  describe('scheduled jobs', () => {
+    beforeEach(async () => {
+      await adapter.connect();
+    });
+
+    it('should add and get scheduled jobs', async () => {
+      await adapter.addScheduledJob('test-job', {
+        pattern: 'job:test',
+        data: { action: 'process' },
+        schedule: { every: 1000 },
+      });
+      
+      const jobs = await adapter.getScheduledJobs();
+      
+      expect(jobs.find((j) => j.name === 'test-job')).toBeDefined();
+    });
+
+    it('should add cron scheduled job', async () => {
+      await adapter.addScheduledJob('cron-job', {
+        pattern: 'job:cron',
+        data: { action: 'cron' },
+        schedule: { cron: '0 * * * *' },
+      });
+      
+      const jobs = await adapter.getScheduledJobs();
+      
+      expect(jobs.find((j) => j.name === 'cron-job')).toBeDefined();
+    });
+
+    it('should remove scheduled job', async () => {
+      await adapter.addScheduledJob('removable-job', {
+        pattern: 'job:remove',
+        data: {},
+        schedule: { every: 1000 },
+      });
+      
+      const removed = await adapter.removeScheduledJob('removable-job');
+      
+      expect(removed).toBe(true);
+      
+      const jobs = await adapter.getScheduledJobs();
+      expect(jobs.find((j) => j.name === 'removable-job')).toBeUndefined();
+    });
+
+    it('should return false when removing non-existent job', async () => {
+      const removed = await adapter.removeScheduledJob('non-existent');
+      
+      expect(removed).toBe(false);
+    });
+
+    it('should throw when adding job while disconnected', async () => {
+      await adapter.disconnect();
+      
+      await expect(
+        adapter.addScheduledJob('fail-job', {
+          pattern: 'job:fail',
+          data: {},
+          schedule: { every: 1000 },
+        }),
+      ).rejects.toThrow('not connected');
+    });
+  });
+
+  describe('features', () => {
+    it('should support all standard queue features', () => {
+      expect(adapter.supports('delayed-messages')).toBe(true);
+      expect(adapter.supports('priority')).toBe(true);
+      expect(adapter.supports('dead-letter-queue')).toBe(true);
+      expect(adapter.supports('retry')).toBe(true);
+      expect(adapter.supports('scheduled-jobs')).toBe(true);
+      expect(adapter.supports('consumer-groups')).toBe(true);
+      expect(adapter.supports('pattern-subscriptions')).toBe(true);
+    });
+  });
+
+  describe('events', () => {
+    it('should register and unregister event handlers', () => {
+      const handler = mock(() => undefined);
+      
+      adapter.on('onReady', handler);
+      adapter.off('onReady', handler);
+      
+      // No assertion needed - just checking no errors
+    });
+
+    it('should emit onError event on connection failure', async () => {
+      // Use a non-routable IP to fail quickly instead of DNS lookup timeout
+      const badAdapter = new RedisQueueAdapter({
+        useSharedClient: false,
+        url: 'redis://10.255.255.1:9999', // Non-routable IP
+      });
+      
+      const onError = mock(() => undefined);
+      badAdapter.on('onError', onError);
+      
+      const connectPromise = badAdapter.connect();
+      
+      // Race between connection attempt and timeout
+      const result = await Promise.race([
+        connectPromise.then(() => 'connected').catch(() => 'error'),
+        new Promise<string>((resolve) => setTimeout(() => resolve('timeout'), 3000)),
+      ]);
+      
+      // We expect either error or timeout, but onError should be called on error
+      expect(result).toBeOneOf(['error', 'timeout']);
+      if (result === 'error') {
+        expect(onError).toHaveBeenCalled();
+      }
+    });
+  });
+});

package/src/queue/queue.service.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Tests for QueueService
+ */
+
+import {
+  describe,
+  test,
+  expect,
+  beforeEach,
+  afterEach,
+} from 'bun:test';
+
+import type { Message } from './types';
+
+import { InMemoryQueueAdapter } from './adapters/memory.adapter';
+import { QueueService } from './queue.service';
+
+describe('QueueService', () => {
+  let adapter: InMemoryQueueAdapter;
+  let service: QueueService;
+
+  beforeEach(async () => {
+    adapter = new InMemoryQueueAdapter();
+    service = new QueueService({ adapter: 'memory' as const });
+    await service.initialize(adapter);
+  });
+
+  afterEach(async () => {
+    await service.stop();
+  });
+
+  describe('lifecycle', () => {
+    test('should initialize with adapter', async () => {
+      expect(service.getAdapter()).toBe(adapter);
+    });
+
+    test('should start and stop correctly', async () => {
+      await service.start();
+      expect(adapter.isConnected()).toBe(true);
+
+      await service.stop();
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    test('should handle multiple start calls', async () => {
+      await service.start();
+      await service.start(); // Should not throw
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    test('should handle multiple stop calls', async () => {
+      await service.start();
+      await service.stop();
+      await service.stop(); // Should not throw
+    });
+
+    test('should throw when getting adapter before initialization', () => {
+      const uninitializedService = new QueueService({ adapter: 'memory' as const });
+      expect(() => uninitializedService.getAdapter()).toThrow('Queue adapter not initialized');
+    });
+
+    test('should throw when starting without initialization', async () => {
+      const uninitializedService = new QueueService({ adapter: 'memory' as const });
+      await expect(uninitializedService.start()).rejects.toThrow('Queue adapter not initialized');
+    });
+  });
+
+  describe('publish/subscribe', () => {
+    test('should publish and receive messages', async () => {
+      await service.start();
+
+      const received: Message[] = [];
+      await service.subscribe('test.pattern', async (message) => {
+        received.push(message);
+      });
+
+      await service.publish('test.pattern', { data: 'hello' });
+
+      expect(received.length).toBe(1);
+      expect(received[0].data).toEqual({ data: 'hello' });
+    });
+
+    test('should publish batch messages', async () => {
+      await service.start();
+
+      const received: Message[] = [];
+      await service.subscribe('batch.*', async (message) => {
+        received.push(message);
+      });
+
+      const ids = await service.publishBatch([
+        { pattern: 'batch.1', data: { index: 1 } },
+        { pattern: 'batch.2', data: { index: 2 } },
+      ]);
+
+      expect(ids.length).toBe(2);
+      expect(received.length).toBe(2);
+    });
+
+    test('should track subscriptions', async () => {
+      await service.start();
+
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      const sub1 = await service.subscribe('pattern1', async () => {});
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      const sub2 = await service.subscribe('pattern2', async () => {});
+
+      expect(sub1.isActive).toBe(true);
+      expect(sub2.isActive).toBe(true);
+
+      // Stop should unsubscribe all
+      await service.stop();
+      expect(sub1.isActive).toBe(false);
+      expect(sub2.isActive).toBe(false);
+    });
+  });
+
+  describe('scheduler', () => {
+    test('should provide access to scheduler', async () => {
+      const scheduler = service.getScheduler();
+      expect(scheduler).toBeDefined();
+    });
+
+    test('should throw when getting scheduler before initialization', () => {
+      const uninitializedService = new QueueService({ adapter: 'memory' as const });
+      expect(() => uninitializedService.getScheduler()).toThrow('Queue scheduler not initialized');
+    });
+
+    test('should start scheduler with service', async () => {
+      const scheduler = service.getScheduler();
+
+      const received: Message[] = [];
+      await service.subscribe('scheduled.test', async (message) => {
+        received.push(message);
+      });
+
+      // Add interval job that fires immediately
+      scheduler.addIntervalJob('test-job', 100000, 'scheduled.test', () => ({ test: true }));
+
+      await service.start();
+
+      // Should have received message immediately due to runImmediately default
+      expect(received.length).toBe(1);
+    });
+  });
+
+  describe('features', () => {
+    test('should check feature support', async () => {
+      await service.start();
+
+      expect(service.supports('pattern-subscriptions')).toBe(true);
+      expect(service.supports('delayed-messages')).toBe(true);
+      expect(service.supports('consumer-groups')).toBe(false);
+    });
+  });
+
+  describe('events', () => {
+    test('should register and unregister event handlers', async () => {
+      await service.start();
+
+      let readyCount = 0;
+      const handler = () => {
+        readyCount++;
+      };
+
+      service.on('onReady', handler);
+      // Reconnect to trigger onReady
+      await adapter.disconnect();
+      await adapter.connect();
+      expect(readyCount).toBe(1);
+
+      service.off('onReady', handler);
+      await adapter.disconnect();
+      await adapter.connect();
+      expect(readyCount).toBe(1); // Should still be 1
+    });
+
+    test('should emit onMessageReceived event', async () => {
+      await service.start();
+
+      let receivedMessage: Message | null = null;
+      service.on('onMessageReceived', (message) => {
+        receivedMessage = message as Message;
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      await service.subscribe('test', async () => {});
+      await service.publish('test', { data: 'test' });
+
+      expect(receivedMessage).not.toBeNull();
+      expect(receivedMessage!.pattern).toBe('test');
+    });
+  });
+
+  describe('scheduled jobs via adapter', () => {
+    test('should add and remove scheduled jobs', async () => {
+      await service.start();
+
+      await service.addScheduledJob('test-scheduled', {
+        pattern: 'scheduled.pattern',
+        schedule: { every: 60000 },
+      });
+
+      const jobs = await service.getScheduledJobs();
+      expect(jobs.some((j) => j.name === 'test-scheduled')).toBe(true);
+
+      const removed = await service.removeScheduledJob('test-scheduled');
+      expect(removed).toBe(true);
+
+      const jobsAfter = await service.getScheduledJobs();
+      expect(jobsAfter.some((j) => j.name === 'test-scheduled')).toBe(false);
+    });
+
+    test('should return false when removing non-existent job', async () => {
+      await service.start();
+
+      const removed = await service.removeScheduledJob('nonexistent');
+      expect(removed).toBe(false);
+    });
+  });
+
+  describe('error handling', () => {
+    test('should handle subscription errors gracefully', async () => {
+      await service.start();
+
+      let errorReceived = false;
+      service.on('onMessageFailed', () => {
+        errorReceived = true;
+      });
+
+      await service.subscribe('error.test', async () => {
+        throw new Error('Handler error');
+      });
+
+      await service.publish('error.test', { data: 'test' });
+
+      expect(errorReceived).toBe(true);
+    });
+  });
+});

package/src/queue/scheduler.test.ts

@@ -12,14 +12,22 @@ import {
 
 import type { Message } from './types';
 
+import { useFakeTimers } from '../testing/test-utils';
+
 import { InMemoryQueueAdapter } from './adapters/memory.adapter';
 import { QueueScheduler, createQueueScheduler } from './scheduler';
 
 describe('QueueScheduler', () => {
   let adapter: InMemoryQueueAdapter;
   let scheduler: QueueScheduler;
+  let advanceTime: (ms: number) => void;
+  let restore: () => void;
 
   beforeEach(async () => {
+    const fakeTimers = useFakeTimers();
+    advanceTime = fakeTimers.advanceTime;
+    restore = fakeTimers.restore;
+
     adapter = new InMemoryQueueAdapter();
     await adapter.connect();
     scheduler = new QueueScheduler(adapter);
@@ -28,6 +36,7 @@ describe('QueueScheduler', () => {
   afterEach(async () => {
     scheduler.stop();
     await adapter.disconnect();
+    restore();
   });
 
   describe('interval jobs', () => {
@@ -40,8 +49,9 @@ describe('QueueScheduler', () => {
       scheduler.addIntervalJob('test-interval', 100000, 'test.interval', () => ({ count: 1 }));
       scheduler.start();
 
-      // Wait a bit for async processing
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      // Advance time and flush async handlers
+      advanceTime(10);
+      await Promise.resolve();
 
       // Should execute immediately
       expect(received.length).toBe(1);
@@ -59,7 +69,8 @@ describe('QueueScheduler', () => {
       }));
       scheduler.start();
 
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      advanceTime(10);
+      await Promise.resolve();
 
       expect(received.length).toBe(1);
       expect((received[0].data as { counter: number }).counter).toBe(1);
@@ -76,7 +87,8 @@ describe('QueueScheduler', () => {
       });
       scheduler.start();
 
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      advanceTime(10);
+      await Promise.resolve();
 
       expect(received.length).toBe(1);
       expect(received[0].metadata.serviceId).toBe('test-service');
@@ -96,20 +108,21 @@ describe('QueueScheduler', () => {
       // Should not have fired yet
       expect(received.length).toBe(0);
 
-      // Wait for timeout
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      // Advance time past the timeout and flush async handlers
+      advanceTime(100);
+      await Promise.resolve();
 
       expect(received.length).toBe(1);
       expect((received[0].data as { fired: boolean }).fired).toBe(true);
     });
 
-    it('should remove job after execution', async () => {
+    it('should remove job after execution', () => {
       scheduler.addTimeoutJob('one-time', 30, 'test.one-time');
       scheduler.start();
 
       expect(scheduler.hasJob('one-time')).toBe(true);
 
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      advanceTime(50);
 
       expect(scheduler.hasJob('one-time')).toBe(false);
     });
@@ -200,7 +213,7 @@ describe('QueueScheduler', () => {
       scheduler.addIntervalJob('test', 100000, 'test');
       // Not calling start()
 
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      advanceTime(50);
       expect(received.length).toBe(0);
     });