@onebun/core 0.1.10 → 0.1.12

package/src/redis/shared-redis.test.ts

@@ -0,0 +1,255 @@
+/**
+ * Shared Redis Provider Tests
+ *
+ * Tests using testcontainers for real Redis integration
+ */
+
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  describe,
+  expect,
+  it,
+} from 'bun:test';
+import { Effect, pipe } from 'effect';
+import {
+  GenericContainer,
+  type StartedTestContainer,
+  Wait,
+} from 'testcontainers';
+
+import {
+  SharedRedisProvider,
+  SharedRedisService,
+  makeSharedRedisLayer,
+  getSharedRedis,
+} from './shared-redis';
+
+describe('SharedRedisProvider', () => {
+  let redisContainer: StartedTestContainer;
+  let redisUrl: string;
+
+  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}`;
+  });
+
+  afterAll(async () => {
+    await SharedRedisProvider.reset();
+    if (redisContainer) {
+      await redisContainer.stop();
+    }
+  });
+
+  afterEach(async () => {
+    await SharedRedisProvider.reset();
+  });
+
+  describe('configuration', () => {
+    it('should configure the provider', () => {
+      expect(SharedRedisProvider.isConfigured()).toBe(false);
+      
+      SharedRedisProvider.configure({ url: redisUrl });
+      
+      expect(SharedRedisProvider.isConfigured()).toBe(true);
+    });
+
+    it('should throw when getClient called without configuration', async () => {
+      await expect(SharedRedisProvider.getClient()).rejects.toThrow(
+        'SharedRedisProvider not configured',
+      );
+    });
+  });
+
+  describe('connection', () => {
+    it('should connect and return a client', async () => {
+      SharedRedisProvider.configure({
+        url: redisUrl,
+        keyPrefix: 'test:',
+      });
+
+      const client = await SharedRedisProvider.getClient();
+      
+      expect(client).toBeDefined();
+      expect(client.isConnected()).toBe(true);
+      expect(SharedRedisProvider.isConnected()).toBe(true);
+    });
+
+    it('should return the same instance on multiple calls', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+
+      const client1 = await SharedRedisProvider.getClient();
+      const client2 = await SharedRedisProvider.getClient();
+      
+      expect(client1).toBe(client2);
+    });
+
+    it('should handle concurrent getClient calls', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+
+      // Call getClient multiple times concurrently
+      const [client1, client2, client3] = await Promise.all([
+        SharedRedisProvider.getClient(),
+        SharedRedisProvider.getClient(),
+        SharedRedisProvider.getClient(),
+      ]);
+      
+      // All should be the same instance
+      expect(client1).toBe(client2);
+      expect(client2).toBe(client3);
+    });
+
+    it('should disconnect properly', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+
+      await SharedRedisProvider.getClient();
+      expect(SharedRedisProvider.isConnected()).toBe(true);
+
+      await SharedRedisProvider.disconnect();
+      
+      expect(SharedRedisProvider.isConnected()).toBe(false);
+    });
+
+    it('should reconnect after disconnect', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+
+      const client1 = await SharedRedisProvider.getClient();
+      await SharedRedisProvider.disconnect();
+
+      const client2 = await SharedRedisProvider.getClient();
+      
+      expect(client2).toBeDefined();
+      expect(client2.isConnected()).toBe(true);
+      // After disconnect and reconnect, we get a new instance
+      expect(client1).not.toBe(client2);
+    });
+  });
+
+  describe('client operations', () => {
+    it('should perform basic Redis operations', async () => {
+      SharedRedisProvider.configure({
+        url: redisUrl,
+        keyPrefix: 'test:ops:',
+      });
+
+      const client = await SharedRedisProvider.getClient();
+      
+      // Set and get
+      await client.set('testkey', 'testvalue');
+      const value = await client.get('testkey');
+      expect(value).toBe('testvalue');
+      
+      // Delete
+      await client.del('testkey');
+      const deleted = await client.get('testkey');
+      expect(deleted).toBeNull();
+    });
+  });
+
+  describe('createClient', () => {
+    it('should create standalone client with custom URL', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+
+      const standalone = SharedRedisProvider.createClient({
+        url: redisUrl,
+        keyPrefix: 'standalone:',
+      });
+      
+      await standalone.connect();
+      expect(standalone.isConnected()).toBe(true);
+      
+      // Should be different from shared client
+      const shared = await SharedRedisProvider.getClient();
+      expect(standalone).not.toBe(shared);
+      
+      await standalone.disconnect();
+    });
+
+    it('should use base options when not specified', async () => {
+      SharedRedisProvider.configure({
+        url: redisUrl,
+        keyPrefix: 'base:',
+        reconnect: true,
+      });
+
+      const standalone = SharedRedisProvider.createClient({});
+      
+      await standalone.connect();
+      expect(standalone.isConnected()).toBe(true);
+      await standalone.disconnect();
+    });
+
+    it('should throw when URL is not available', () => {
+      // Don't configure provider
+      expect(() => SharedRedisProvider.createClient({})).toThrow('Redis URL is required');
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset provider state completely', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+      await SharedRedisProvider.getClient();
+      
+      expect(SharedRedisProvider.isConnected()).toBe(true);
+      expect(SharedRedisProvider.isConfigured()).toBe(true);
+
+      await SharedRedisProvider.reset();
+      
+      expect(SharedRedisProvider.isConnected()).toBe(false);
+      expect(SharedRedisProvider.isConfigured()).toBe(false);
+    });
+  });
+
+  describe('Effect.js integration', () => {
+    it('should work with makeSharedRedisLayer', async () => {
+      const layer = makeSharedRedisLayer({
+        url: redisUrl,
+        keyPrefix: 'effect:',
+      });
+
+      const program = pipe(
+        SharedRedisService,
+        Effect.flatMap((redis) =>
+          Effect.promise(async () => {
+            await redis.set('effect-test', 'value');
+
+            return await redis.get('effect-test');
+          }),
+        ),
+      );
+
+      const result = await Effect.runPromise(Effect.provide(program, layer));
+      
+      expect(result).toBe('value');
+    });
+
+    it('should fail getSharedRedis when not configured', async () => {
+      // Reset to ensure not configured
+      await SharedRedisProvider.reset();
+      
+      const result = await Effect.runPromiseExit(getSharedRedis);
+      
+      expect(result._tag).toBe('Failure');
+    });
+
+    it('should succeed getSharedRedis when configured', async () => {
+      SharedRedisProvider.configure({ url: redisUrl });
+      
+      const result = await Effect.runPromiseExit(getSharedRedis);
+      
+      expect(result._tag).toBe('Success');
+    });
+  });
+});

package/src/testing/test-utils.ts

@@ -5,6 +5,8 @@
 
 import { Effect, Layer } from 'effect';
 
+import type { IConfig, OneBunAppConfig } from '../module/config.interface';
+
 import type { Logger, SyncLogger } from '@onebun/logger';
 import { LoggerService } from '@onebun/logger';
 
@@ -337,3 +339,57 @@ export function createMockSyncLogger(): SyncLogger {
 export function makeMockLoggerLayer(): Layer.Layer<Logger, never, never> {
   return Layer.succeed(LoggerService, createMockLogger());
 }
+
+/**
+ * Create a mock config for testing.
+ * Returns an IConfig-compatible object with customizable values.
+ * 
+ * @param values - Optional object with config values that get() will return
+ * @param options - Optional configuration options
+ * @returns An IConfig-compatible mock object
+ * 
+ * @example
+ * ```typescript
+ * const mockConfig = createMockConfig({ 
+ *   'server.port': 3000,
+ *   'server.host': '0.0.0.0'
+ * });
+ * controller.initializeController(mockLogger, mockConfig);
+ * ```
+ */
+export function createMockConfig(
+  values: Record<string, unknown> = {},
+  options?: { isInitialized?: boolean },
+): IConfig<OneBunAppConfig> {
+  const isInitialized = options?.isInitialized ?? true;
+  
+  return {
+    get(path: string): unknown {
+      if (!isInitialized) {
+        throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
+      }
+
+      return values[path];
+    },
+    get values(): OneBunAppConfig {
+      if (!isInitialized) {
+        throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
+      }
+
+      return values as unknown as OneBunAppConfig;
+    },
+    getSafeConfig(): OneBunAppConfig {
+      if (!isInitialized) {
+        throw new Error('Configuration not initialized. Provide envSchema in ApplicationOptions.');
+      }
+
+      return values as unknown as OneBunAppConfig;
+    },
+    get isInitialized(): boolean {
+      return isInitialized;
+    },
+    async initialize(): Promise<void> {
+      // No-op for mock
+    },
+  };
+}

package/src/websocket/ws-client.test.ts

@@ -13,6 +13,8 @@ import {
 
 import type { WsServiceDefinition } from './ws-service-definition';
 
+import { useFakeTimers } from '../testing/test-utils';
+
 import { createWsClient } from './ws-client';
 import { WsConnectionState } from './ws-client.types';
 import { WsHandlerType } from './ws.types';
@@ -359,50 +361,84 @@ describe('WsClient', () => {
     });
 
     it('should emit message and wait for acknowledgement', async () => {
-      const definition = createMockDefinition();
-      const client = createWsClient(definition, { 
-        url: 'ws://localhost:3000',
-        timeout: 1000,
-      });
-      
-      await client.connect();
-      
-      const ws = MockWebSocket.getLastInstance();
-      
-      // Start emit (returns promise)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const emitPromise = (client as any).TestGateway.emit('test:event', { foo: 'bar' });
-      
-      // Simulate server acknowledgement
-      await new Promise(resolve => setTimeout(resolve, 10));
-      const sent = JSON.parse(ws!.sentMessages[ws!.sentMessages.length - 1]);
-      ws?.receiveMessage(JSON.stringify({ 
-        event: 'ack', 
-        data: { result: 'ok' }, 
-        ack: sent.ack,
-      }));
-      
-      const result = await emitPromise;
-      expect(result).toEqual({ result: 'ok' });
+      const { advanceTime, restore } = useFakeTimers();
+
+      try {
+        const definition = createMockDefinition();
+        const client = createWsClient(definition, { 
+          url: 'ws://localhost:3000',
+          timeout: 1000,
+        });
+        
+        // Advance time to trigger MockWebSocket's async open
+        const connectPromise = client.connect();
+        advanceTime(1);
+        await connectPromise;
+        
+        const ws = MockWebSocket.getLastInstance();
+        
+        // Start emit (returns promise)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const emitPromise = (client as any).TestGateway.emit('test:event', { foo: 'bar' });
+        
+        // Advance time to process sent message
+        advanceTime(10);
+        const sent = JSON.parse(ws!.sentMessages[ws!.sentMessages.length - 1]);
+        ws?.receiveMessage(JSON.stringify({ 
+          event: 'ack', 
+          data: { result: 'ok' }, 
+          ack: sent.ack,
+        }));
+        
+        const result = await emitPromise;
+        expect(result).toEqual({ result: 'ok' });
+      } finally {
+        restore();
+      }
     });
 
     it('should timeout emit if no acknowledgement', async () => {
-      const definition = createMockDefinition();
-      const client = createWsClient(definition, { 
-        url: 'ws://localhost:3000',
-        timeout: 50, // Short timeout for test
-      });
-      
-      await client.connect();
-      
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const emitPromise = (client as any).TestGateway.emit('test:event', { foo: 'bar' });
-      
-      await expect(emitPromise).rejects.toThrow('Request timeout');
+      const { advanceTime, restore } = useFakeTimers();
+
+      try {
+        const definition = createMockDefinition();
+        const client = createWsClient(definition, { 
+          url: 'ws://localhost:3000',
+          timeout: 50, // Short timeout for test
+        });
+        
+        // Advance time to trigger MockWebSocket's async open
+        const connectPromise = client.connect();
+        advanceTime(1);
+        await connectPromise;
+        
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const emitPromise = (client as any).TestGateway.emit('test:event', { foo: 'bar' });
+        
+        // Advance time past the timeout
+        advanceTime(100);
+        
+        await expect(emitPromise).rejects.toThrow('Request timeout');
+      } finally {
+        restore();
+      }
     });
   });
 
   describe('reconnection', () => {
+    let advanceTime: (ms: number) => void;
+    let restore: () => void;
+
+    beforeEach(() => {
+      const fakeTimers = useFakeTimers();
+      advanceTime = fakeTimers.advanceTime;
+      restore = fakeTimers.restore;
+    });
+
+    afterEach(() => {
+      restore();
+    });
+
     it('should attempt reconnection on disconnect', async () => {
       const definition = createMockDefinition();
       const client = createWsClient(definition, { 
@@ -413,15 +449,19 @@ describe('WsClient', () => {
       });
       const reconnectAttemptHandler = mock(() => undefined);
       
-      await client.connect();
+      // Advance time to trigger MockWebSocket's async open
+      const connectPromise = client.connect();
+      advanceTime(1);
+      await connectPromise;
+      
       client.on('reconnect_attempt', reconnectAttemptHandler);
       
       // Simulate server disconnect
       const ws = MockWebSocket.getLastInstance();
       ws?.close(1006, 'Connection lost');
       
-      // Wait for reconnect attempt
-      await new Promise(resolve => setTimeout(resolve, 50));
+      // Advance time for reconnect attempt
+      advanceTime(50);
       
       expect(reconnectAttemptHandler).toHaveBeenCalled();
     });
@@ -436,7 +476,11 @@ describe('WsClient', () => {
       });
       let reconnectAttemptCount = 0;
       
-      await client.connect();
+      // Advance time to trigger MockWebSocket's async open
+      const connectPromise = client.connect();
+      advanceTime(1);
+      await connectPromise;
+      
       client.on('reconnect_attempt', (attempt) => {
         reconnectAttemptCount = attempt;
       });
@@ -445,8 +489,8 @@ describe('WsClient', () => {
       const ws = MockWebSocket.getLastInstance();
       ws?.close(1006, 'Connection lost');
       
-      // Wait for first reconnect attempt
-      await new Promise(resolve => setTimeout(resolve, 50));
+      // Advance time for first reconnect attempt
+      advanceTime(50);
       
       expect(reconnectAttemptCount).toBeGreaterThanOrEqual(1);
     });
@@ -459,19 +503,23 @@ describe('WsClient', () => {
       });
       const reconnectAttemptHandler = mock(() => undefined);
       
-      await client.connect();
-      client.on('reconnect_attempt', reconnectAttemptHandler);
+      // Advance time to trigger MockWebSocket's async open
+      const connectPromise = client.connect();
+      advanceTime(1);
+      await connectPromise;
       
-      const initialInstanceCount = MockWebSocket.instances.length;
+      client.on('reconnect_attempt', reconnectAttemptHandler);
       
       // Simulate disconnect
       const ws = MockWebSocket.getLastInstance();
       ws?.close(1006, 'Connection lost');
       
-      await new Promise(resolve => setTimeout(resolve, 50));
+      advanceTime(50);
       
+      // Main assertion: reconnect handler should not be called when reconnect is disabled
       expect(reconnectAttemptHandler).not.toHaveBeenCalled();
-      expect(MockWebSocket.instances.length).toBe(initialInstanceCount);
+      // Note: We don't check MockWebSocket.instances.length here because it's a static array
+      // that can be affected by parallel test runs. The handler check is sufficient.
     });
   });