@onebun/core 0.2.8 → 0.2.10

package/src/module/service.test.ts

@@ -1,6 +1,8 @@
 /* eslint-disable
    @typescript-eslint/no-unused-vars,
-   @typescript-eslint/no-explicit-any */
+   @typescript-eslint/no-explicit-any,
+   @typescript-eslint/naming-convention,
+   jest/unbound-method */
 import {
   describe,
   test,
@@ -10,6 +12,9 @@ import {
 } from 'bun:test';
 import { Effect } from 'effect';
 
+import type { SyncLogger } from '@onebun/logger';
+
+import { createTestService } from '../testing/service-helpers';
 import { createMockConfig } from '../testing/test-utils';
 
 import {
@@ -19,50 +24,48 @@ import {
 } from './config.interface';
 import { BaseService } from './service';
 
-describe('BaseService', () => {
-  let mockLogger: any;
-  let mockConfig: IConfig<OneBunAppConfig>;
-
-  beforeEach(() => {
-    mockLogger = {
-      child: mock((context: any) => mockLogger),
-      debug: mock(),
-      info: mock(),
-      warn: mock(),
-      error: mock(),
-    };
-    
-    mockConfig = createMockConfig({
-      /* eslint-disable @typescript-eslint/naming-convention */
-      'database.host': 'localhost',
-      'app.name': 'test-app',
-      /* eslint-enable @typescript-eslint/naming-convention */
-    });
-  });
+function createMockLogger(): SyncLogger {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  const noOp = () => {};
+  const logger: SyncLogger = {
+    trace: mock(noOp),
+    debug: mock(noOp),
+    info: mock(noOp),
+    warn: mock(noOp),
+    error: mock(noOp),
+    fatal: mock(noOp),
+    child: mock(() => logger),
+  };
+
+  return logger;
+}
 
+describe('BaseService', () => {
   describe('Initialization via initializeService', () => {
     test('should initialize service with logger and config via initializeService', () => {
       class TestService extends BaseService {}
 
-      const service = new TestService();
-      expect(service).toBeInstanceOf(BaseService);
-      expect(service.isInitialized).toBe(false);
+      const { instance: service, config } = createTestService(TestService, {
+        config: {
+          'database.host': 'localhost',
+          'app.name': 'test-app',
+        },
+      });
 
-      // Initialize service
-      service.initializeService(mockLogger, mockConfig);
-      
+      expect(service).toBeInstanceOf(BaseService);
       expect(service.isInitialized).toBe(true);
       expect((service as any).logger).toBeDefined();
-      expect((service as any).config).toBe(mockConfig);
+      expect((service as any).config).toBe(config);
     });
 
     test('should initialize service with logger and NotInitializedConfig', () => {
       class TestService extends BaseService {}
 
       const service = new TestService();
+      const mockLogger = createMockLogger();
       const notInitConfig = new NotInitializedConfig();
       service.initializeService(mockLogger, notInitConfig);
-      
+
       expect(service.isInitialized).toBe(true);
       expect((service as any).logger).toBeDefined();
       expect((service as any).config).toBeInstanceOf(NotInitializedConfig);
@@ -72,6 +75,7 @@ describe('BaseService', () => {
       class TestService extends BaseService {}
 
       const service = new TestService();
+      const mockConfig = createMockConfig({});
       expect(() => service.initializeService(undefined as any, mockConfig))
         .toThrow('Logger is required for service TestService');
     });
@@ -80,6 +84,7 @@ describe('BaseService', () => {
       class TestService extends BaseService {}
 
       const service = new TestService();
+      const mockConfig = createMockConfig({});
       expect(() => service.initializeService(null as any, mockConfig))
         .toThrow('Logger is required for service TestService');
     });
@@ -87,15 +92,19 @@ describe('BaseService', () => {
     test('should not reinitialize if already initialized', () => {
       class TestService extends BaseService {}
 
-      const service = new TestService();
-      service.initializeService(mockLogger, mockConfig);
-      
-      const otherLogger = { ...mockLogger, child: mock(() => ({ ...mockLogger })) };
+      const { instance: service, config } = createTestService(TestService, {
+        config: {
+          'database.host': 'localhost',
+          'app.name': 'test-app',
+        },
+      });
+
+      const otherLogger = createMockLogger();
       const otherConfig = createMockConfig({ 'other': 'config' });
       service.initializeService(otherLogger, otherConfig);
-      
-      // Should still have original logger (no reinit)
-      expect((service as any).config).toBe(mockConfig);
+
+      // Should still have original config (no reinit)
+      expect((service as any).config).toBe(config);
     });
   });
 
@@ -113,8 +122,8 @@ describe('BaseService', () => {
     let service: TestService;
 
     beforeEach(() => {
-      service = new TestService();
-      service.initializeService(mockLogger, mockConfig);
+      const result = createTestService(TestService);
+      service = result.instance;
     });
 
     test('should run effect successfully', async () => {
@@ -125,14 +134,14 @@ describe('BaseService', () => {
 
     test('should handle effect failure', async () => {
       const effect = Effect.fail(new Error('Test error'));
-      
+
       await expect(service.testRunEffect(effect)).rejects.toThrow('Test error');
     });
 
     test('should format Error instances', () => {
       const error = new Error('Test error');
       const formattedError = service.testFormatError(error);
-      
+
       expect(formattedError).toBe(error);
       expect(formattedError.message).toBe('Test error');
     });
@@ -140,7 +149,7 @@ describe('BaseService', () => {
     test('should format string errors', () => {
       const error = 'String error message';
       const formattedError = service.testFormatError(error);
-      
+
       expect(formattedError).toBeInstanceOf(Error);
       expect(formattedError.message).toBe('String error message');
     });
@@ -148,7 +157,7 @@ describe('BaseService', () => {
     test('should format unknown errors', () => {
       const error = { unknown: 'object' };
       const formattedError = service.testFormatError(error);
-      
+
       expect(formattedError).toBeInstanceOf(Error);
       expect(formattedError.message).toBe('[object Object]'); // String(object) result
     });
@@ -156,10 +165,10 @@ describe('BaseService', () => {
     test('should format null/undefined errors', () => {
       const nullError = service.testFormatError(null);
       const undefinedError = service.testFormatError(undefined);
-      
+
       expect(nullError).toBeInstanceOf(Error);
       expect(nullError.message).toBe('null'); // String(null) result
-      
+
       expect(undefinedError).toBeInstanceOf(Error);
       expect(undefinedError.message).toBe('undefined'); // String(undefined) result
     });
@@ -178,6 +187,12 @@ describe('BaseService', () => {
         }
       }
 
+      const mockLogger = createMockLogger();
+      const mockConfig = createMockConfig({
+        'database.host': 'localhost',
+        'app.name': 'test-app',
+      });
+
       // Set init context before construction (as the framework does)
       BaseService.setInitContext(mockLogger, mockConfig);
       let service: TestService;
@@ -203,6 +218,11 @@ describe('BaseService', () => {
         }
       }
 
+      const mockLogger = createMockLogger();
+      const mockConfig = createMockConfig({
+        'database.host': 'localhost',
+      });
+
       BaseService.setInitContext(mockLogger, mockConfig);
       let service: TestService;
       try {
@@ -217,6 +237,9 @@ describe('BaseService', () => {
     test('should create child logger with correct className in constructor', () => {
       class MyCustomService extends BaseService {}
 
+      const mockLogger = createMockLogger();
+      const mockConfig = createMockConfig({});
+
       BaseService.setInitContext(mockLogger, mockConfig);
       try {
         new MyCustomService();
@@ -240,6 +263,9 @@ describe('BaseService', () => {
     test('initializeService should be a no-op if already initialized via init context', () => {
       class TestService extends BaseService {}
 
+      const mockLogger = createMockLogger();
+      const mockConfig = createMockConfig({});
+
       BaseService.setInitContext(mockLogger, mockConfig);
       let service: TestService;
       try {
@@ -251,7 +277,7 @@ describe('BaseService', () => {
       expect(service.isInitialized).toBe(true);
 
       // Call initializeService again — should be a no-op
-      const otherLogger = { ...mockLogger, child: mock(() => ({ ...mockLogger })) };
+      const otherLogger = createMockLogger();
       const otherConfig = createMockConfig({ other: 'config' });
       service.initializeService(otherLogger, otherConfig);
 
@@ -260,6 +286,9 @@ describe('BaseService', () => {
     });
 
     test('clearInitContext should prevent subsequent constructors from picking up context', () => {
+      const mockLogger = createMockLogger();
+      const mockConfig = createMockConfig({});
+
       BaseService.setInitContext(mockLogger, mockConfig);
       BaseService.clearInitContext();
 
@@ -275,13 +304,12 @@ describe('BaseService', () => {
       class TestService extends BaseService {
         async testComplexEffect() {
           const effect = Effect.succeed(84); // Simplify to avoid generator complexity
-          
+
           return await this.runEffect(effect as any);
         }
       }
 
-      const service = new TestService();
-      service.initializeService(mockLogger, mockConfig);
+      const { instance: service } = createTestService(TestService);
       const result = await service.testComplexEffect();
       expect(result).toBe(84);
     });
@@ -291,13 +319,12 @@ describe('BaseService', () => {
         testStackTrace() {
           const originalError = new Error('Original error');
           const formattedError = this.formatError(originalError);
-          
+
           expect(formattedError).toBe(originalError); // Same Error instance returned
         }
       }
 
-      const service = new TestService();
-      service.initializeService(mockLogger, mockConfig);
+      const { instance: service } = createTestService(TestService);
       service.testStackTrace();
     });
   });

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

@@ -14,45 +14,27 @@ import {
   it,
   mock,
 } from 'bun:test';
-import {
-  GenericContainer,
-  type StartedTestContainer,
-  Wait,
-} from 'testcontainers';
 
 import { SharedRedisProvider } from '../../redis/shared-redis';
+import { createRedisContainer, type TestContainer } from '../../testing/containers';
+
 
 import { RedisQueueAdapter, createRedisQueueAdapter } from './redis.adapter';
 
 describe('RedisQueueAdapter', () => {
-  let redisContainer: StartedTestContainer;
-  let redisUrl: string;
+  let redis: TestContainer;
   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}`;
+    redis = await createRedisContainer();
 
     // Configure shared Redis
-    SharedRedisProvider.configure({ url: redisUrl });
+    SharedRedisProvider.configure({ url: redis.url });
   });
 
   afterAll(async () => {
     await SharedRedisProvider.reset();
-    if (redisContainer) {
-      await redisContainer.stop();
-    }
+    await redis.stop();
   });
 
   beforeEach(async () => {
@@ -125,7 +107,7 @@ describe('RedisQueueAdapter', () => {
     it('should create own client when useSharedClient is false', async () => {
       const ownAdapter = new RedisQueueAdapter({
         useSharedClient: false,
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'own:',
       });
 

package/src/queue/docs-examples.test.ts

@@ -435,7 +435,7 @@ describe('Custom adapter NATS JetStream (docs/api/queue.md)', () => {
     class NatsJetStreamAdapter implements QueueAdapter {
       readonly name = 'nats-jetstream';
       readonly type = 'jetstream';
-      constructor(private opts: { servers: string; stream?: string }) {}
+      constructor(private opts: { servers: string; streams?: Array<{ name: string; subjects: string[] }> }) {}
       async connect(): Promise<void> {}
       async disconnect(): Promise<void> {}
       isConnected(): boolean {
@@ -473,7 +473,7 @@ describe('Custom adapter NATS JetStream (docs/api/queue.md)', () => {
 
     const adapter = new NatsJetStreamAdapter({
       servers: 'nats://localhost:4222',
-      stream: 'EVENTS',
+      streams: [{ name: 'EVENTS', subjects: ['events.>'] }],
     });
     await adapter.connect();
     expect(adapter.name).toBe('nats-jetstream');

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

@@ -13,11 +13,8 @@ import {
   it,
 } from 'bun:test';
 import { Effect, pipe } from 'effect';
-import {
-  GenericContainer,
-  type StartedTestContainer,
-  Wait,
-} from 'testcontainers';
+
+import { createRedisContainer, type TestContainer } from '../testing/containers';
 
 import {
   SharedRedisProvider,
@@ -27,30 +24,15 @@ import {
 } from './shared-redis';
 
 describe('SharedRedisProvider', () => {
-  let redisContainer: StartedTestContainer;
-  let redisUrl: string;
+  let redis: TestContainer;
 
   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}`;
+    redis = await createRedisContainer();
   });
 
   afterAll(async () => {
     await SharedRedisProvider.reset();
-    if (redisContainer) {
-      await redisContainer.stop();
-    }
+    await redis.stop();
   });
 
   afterEach(async () => {
@@ -61,7 +43,7 @@ describe('SharedRedisProvider', () => {
     it('should configure the provider', () => {
       expect(SharedRedisProvider.isConfigured()).toBe(false);
       
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
       
       expect(SharedRedisProvider.isConfigured()).toBe(true);
     });
@@ -76,7 +58,7 @@ describe('SharedRedisProvider', () => {
   describe('connection', () => {
     it('should connect and return a client', async () => {
       SharedRedisProvider.configure({
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'test:',
       });
 
@@ -88,7 +70,7 @@ describe('SharedRedisProvider', () => {
     });
 
     it('should return the same instance on multiple calls', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
 
       const client1 = await SharedRedisProvider.getClient();
       const client2 = await SharedRedisProvider.getClient();
@@ -97,7 +79,7 @@ describe('SharedRedisProvider', () => {
     });
 
     it('should handle concurrent getClient calls', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
 
       // Call getClient multiple times concurrently
       const [client1, client2, client3] = await Promise.all([
@@ -112,7 +94,7 @@ describe('SharedRedisProvider', () => {
     });
 
     it('should disconnect properly', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
 
       await SharedRedisProvider.getClient();
       expect(SharedRedisProvider.isConnected()).toBe(true);
@@ -123,7 +105,7 @@ describe('SharedRedisProvider', () => {
     });
 
     it('should reconnect after disconnect', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
 
       const client1 = await SharedRedisProvider.getClient();
       await SharedRedisProvider.disconnect();
@@ -140,7 +122,7 @@ describe('SharedRedisProvider', () => {
   describe('client operations', () => {
     it('should perform basic Redis operations', async () => {
       SharedRedisProvider.configure({
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'test:ops:',
       });
 
@@ -160,10 +142,10 @@ describe('SharedRedisProvider', () => {
 
   describe('createClient', () => {
     it('should create standalone client with custom URL', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
 
       const standalone = SharedRedisProvider.createClient({
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'standalone:',
       });
       
@@ -179,7 +161,7 @@ describe('SharedRedisProvider', () => {
 
     it('should use base options when not specified', async () => {
       SharedRedisProvider.configure({
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'base:',
         reconnect: true,
       });
@@ -199,7 +181,7 @@ describe('SharedRedisProvider', () => {
 
   describe('reset', () => {
     it('should reset provider state completely', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
       await SharedRedisProvider.getClient();
       
       expect(SharedRedisProvider.isConnected()).toBe(true);
@@ -215,17 +197,17 @@ describe('SharedRedisProvider', () => {
   describe('Effect.js integration', () => {
     it('should work with makeSharedRedisLayer', async () => {
       const layer = makeSharedRedisLayer({
-        url: redisUrl,
+        url: redis.url,
         keyPrefix: 'effect:',
       });
 
       const program = pipe(
         SharedRedisService,
-        Effect.flatMap((redis) =>
+        Effect.flatMap((redisClient) =>
           Effect.promise(async () => {
-            await redis.set('effect-test', 'value');
+            await redisClient.set('effect-test', 'value');
 
-            return await redis.get('effect-test');
+            return await redisClient.get('effect-test');
           }),
         ),
       );
@@ -245,7 +227,7 @@ describe('SharedRedisProvider', () => {
     });
 
     it('should succeed getSharedRedis when configured', async () => {
-      SharedRedisProvider.configure({ url: redisUrl });
+      SharedRedisProvider.configure({ url: redis.url });
       
       const result = await Effect.runPromiseExit(getSharedRedis);
       

package/src/testing/containers.test.ts

@@ -0,0 +1,35 @@
+import {
+  describe,
+  expect,
+  test,
+} from 'bun:test';
+
+import { createNatsContainer, createRedisContainer } from './containers';
+
+describe('createRedisContainer', () => {
+  test('starts redis and returns connection details', async () => {
+    const redis = await createRedisContainer();
+    try {
+      expect(redis.url).toMatch(/^redis:\/\/.+:\d+$/);
+      expect(redis.host).toBeDefined();
+      expect(redis.port).toBeGreaterThan(0);
+      expect(redis.container).toBeDefined();
+    } finally {
+      await redis.stop();
+    }
+  }, 60000);
+});
+
+describe('createNatsContainer', () => {
+  test('starts nats and returns connection details', async () => {
+    const nats = await createNatsContainer();
+    try {
+      expect(nats.url).toMatch(/^nats:\/\/.+:\d+$/);
+      expect(nats.host).toBeDefined();
+      expect(nats.port).toBeGreaterThan(0);
+      expect(nats.container).toBeDefined();
+    } finally {
+      await nats.stop();
+    }
+  }, 60000);
+});

package/src/testing/containers.ts

@@ -0,0 +1,89 @@
+import { GenericContainer, Wait } from 'testcontainers';
+
+import type { StartedTestContainer } from 'testcontainers';
+
+export interface TestContainer {
+  url: string;
+  host: string;
+  port: number;
+  container: StartedTestContainer;
+  stop(): Promise<void>;
+}
+
+export interface RedisContainerOptions {
+  image?: string;
+  startupTimeout?: number;
+}
+
+export interface NatsContainerOptions {
+  image?: string;
+  startupTimeout?: number;
+  enableJetStream?: boolean;
+}
+
+const DEFAULT_STARTUP_TIMEOUT = 30_000;
+const REDIS_PORT = 6379;
+const NATS_PORT = 4222;
+
+export async function createRedisContainer(
+  options?: RedisContainerOptions,
+): Promise<TestContainer> {
+  const image = options?.image ?? 'redis:7-alpine';
+  const startupTimeout = options?.startupTimeout ?? DEFAULT_STARTUP_TIMEOUT;
+
+  const container = await new GenericContainer(image)
+    .withExposedPorts(REDIS_PORT)
+    .withWaitStrategy(Wait.forLogMessage(/.*Ready to accept connections.*/))
+    .withStartupTimeout(startupTimeout)
+    .withLogConsumer(() => {
+      // Suppress container logs in tests
+    })
+    .start();
+
+  const host = container.getHost();
+  const port = container.getMappedPort(REDIS_PORT);
+
+  return {
+    url: `redis://${host}:${port}`,
+    host,
+    port,
+    container,
+    async stop() {
+      await container.stop();
+    },
+  };
+}
+
+export async function createNatsContainer(
+  options?: NatsContainerOptions,
+): Promise<TestContainer> {
+  const image = options?.image ?? 'nats:2.10-alpine';
+  const startupTimeout = options?.startupTimeout ?? DEFAULT_STARTUP_TIMEOUT;
+  const enableJetStream = options?.enableJetStream ?? false;
+
+  let builder = new GenericContainer(image)
+    .withExposedPorts(NATS_PORT)
+    .withWaitStrategy(Wait.forLogMessage(/.*Server is ready.*/))
+    .withStartupTimeout(startupTimeout)
+    .withLogConsumer(() => {
+      // Suppress container logs in tests
+    });
+
+  if (enableJetStream) {
+    builder = builder.withCommand(['--js']);
+  }
+
+  const container = await builder.start();
+  const host = container.getHost();
+  const port = container.getMappedPort(NATS_PORT);
+
+  return {
+    url: `nats://${host}:${port}`,
+    host,
+    port,
+    container,
+    async stop() {
+      await container.stop();
+    },
+  };
+}