@geekmidas/services 9.0.2 → 10.0.0-alpha.0

package/src/__tests__/index.spec.ts

@@ -1,564 +0,0 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
-import { ConsoleLogger } from '@geekmidas/logger/console';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { serviceContext } from '../context';
-import type { Service } from '../index';
-import { ServiceDiscovery } from '../index';
-
-describe('ServiceDiscovery', () => {
-	let _logger: ConsoleLogger;
-	let envParser: EnvironmentParser<{}>;
-
-	beforeEach(() => {
-		_logger = new ConsoleLogger({ app: 'test' });
-		envParser = new EnvironmentParser({ ...process.env });
-
-		// Reset singleton between tests
-		(ServiceDiscovery as any)._instance = undefined;
-	});
-
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe('Singleton Pattern', () => {
-		it('should return same instance on multiple calls', () => {
-			const instance1 = ServiceDiscovery.getInstance(envParser);
-			const instance2 = ServiceDiscovery.getInstance(envParser);
-
-			expect(instance1).toBe(instance2);
-		});
-
-		it('should create instance only once', () => {
-			const instance1 = ServiceDiscovery.getInstance(envParser);
-			const instance2 = ServiceDiscovery.getInstance(envParser);
-			const instance3 = ServiceDiscovery.getInstance(envParser);
-
-			expect(instance1).toBe(instance2);
-			expect(instance2).toBe(instance3);
-		});
-
-		it('should provide access to envParser', () => {
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			expect(discovery.envParser).toBe(envParser);
-		});
-	});
-
-	describe('Service Registration', () => {
-		it('should register a single service', async () => {
-			const mockService = {
-				serviceName: 'database' as const,
-				async register() {
-					return { connected: true };
-				},
-			} satisfies Service<'database', { connected: boolean }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([mockService]);
-
-			expect(services).toHaveProperty('database');
-			expect(services.database).toEqual({ connected: true });
-		});
-
-		it('should register multiple services', async () => {
-			const databaseService = {
-				serviceName: 'database' as const,
-				async register() {
-					return { connected: true };
-				},
-			} satisfies Service<'database', { connected: boolean }>;
-
-			const cacheService = {
-				serviceName: 'cache' as const,
-				async register() {
-					return { ready: true };
-				},
-			} satisfies Service<'cache', { ready: boolean }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([
-				databaseService,
-				cacheService,
-			]);
-
-			expect(services).toHaveProperty('database');
-			expect(services).toHaveProperty('cache');
-			expect(services.database).toEqual({ connected: true });
-			expect(services.cache).toEqual({ ready: true });
-		});
-
-		it('should call register method with envParser and context', async () => {
-			const registerSpy = vi.fn().mockResolvedValue({ data: 'test' });
-
-			const mockService = {
-				serviceName: 'test' as const,
-				register: registerSpy,
-			} satisfies Service<'test', { data: string }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([mockService]);
-
-			expect(registerSpy).toHaveBeenCalledWith({
-				envParser,
-				context: serviceContext,
-			});
-			expect(registerSpy).toHaveBeenCalledTimes(1);
-		});
-
-		it('should handle synchronous register methods', async () => {
-			const mockService = {
-				serviceName: 'sync' as const,
-				register() {
-					return { value: 42 };
-				},
-			} satisfies Service<'sync', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([mockService]);
-
-			expect(services.sync).toEqual({ value: 42 });
-		});
-	});
-
-	describe('Service Caching', () => {
-		it('should cache service instances', async () => {
-			const registerSpy = vi.fn().mockResolvedValue({ instance: 1 });
-
-			const mockService = {
-				serviceName: 'cached' as const,
-				register: registerSpy,
-			} satisfies Service<'cached', { instance: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			const services1 = await discovery.register([mockService]);
-			const services2 = await discovery.register([mockService]);
-
-			// Should only call register once
-			expect(registerSpy).toHaveBeenCalledTimes(1);
-
-			// Should return same instance
-			expect(services1.cached).toBe(services2.cached);
-			expect(services2.cached).toEqual({ instance: 1 });
-		});
-
-		it('should return cached instance even after registration', async () => {
-			const mockService = {
-				serviceName: 'persistent' as const,
-				async register() {
-					return { id: Math.random() };
-				},
-			} satisfies Service<'persistent', { id: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			const services1 = await discovery.register([mockService]);
-			const firstId = services1.persistent.id;
-
-			const services2 = await discovery.register([mockService]);
-			const secondId = services2.persistent.id;
-
-			// Same instance returned
-			expect(firstId).toBe(secondId);
-		});
-
-		it('should cache different services independently', async () => {
-			const service1 = {
-				serviceName: 'service1' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'service1', { value: number }>;
-
-			const service2 = {
-				serviceName: 'service2' as const,
-				async register() {
-					return { value: 2 };
-				},
-			} satisfies Service<'service2', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			const result = await discovery.register([service1, service2]);
-
-			expect(result.service1).toEqual({ value: 1 });
-			expect(result.service2).toEqual({ value: 2 });
-			expect(result.service1).not.toBe(result.service2);
-		});
-	});
-
-	describe('get() method', () => {
-		it('should throw error for non-existent service', () => {
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			// Note: get() throws synchronously, not as a rejected Promise
-			// Also relies on services Map which is not populated by register()
-			expect(() => discovery.get('nonexistent')).toThrow(
-				"Service 'nonexistent' not found in service discovery",
-			);
-		});
-
-		it.skip('should retrieve registered service - SKIPPED: requires services Map to be populated', async () => {
-			// This test is skipped because the current implementation doesn't
-			// populate the services Map in the register() method
-			const mockService = {
-				serviceName: 'test' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'test', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([mockService]);
-
-			// This would fail because services Map is not populated
-			// const result = await discovery.get('test');
-			// expect(result).toEqual({ value: 1 });
-		});
-	});
-
-	describe('getMany() method', () => {
-		it.skip('should get multiple services at once - SKIPPED: requires services Map', async () => {
-			// This test is skipped because getMany() relies on get() which
-			// requires services Map to be populated by register()
-			const service1 = {
-				serviceName: 'db' as const,
-				async register() {
-					return { connected: true };
-				},
-			} satisfies Service<'db', { connected: boolean }>;
-
-			const service2 = {
-				serviceName: 'cache' as const,
-				async register() {
-					return { ready: true };
-				},
-			} satisfies Service<'cache', { ready: boolean }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([service1, service2]);
-
-			// This would fail because services Map is not populated
-			// const result = await discovery.getMany(['db', 'cache']);
-		});
-
-		it('should return empty object for empty array', async () => {
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			const result = await discovery.getMany([]);
-
-			expect(result).toEqual({});
-		});
-
-		it.skip('should throw for any non-existent service in array - SKIPPED: requires services Map', async () => {
-			// Skipped because getMany() requires services Map to be populated
-			const service1 = {
-				serviceName: 'exists' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'exists', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([service1]);
-
-			// Would fail because services Map not populated
-			// await expect(
-			//   discovery.getMany(['exists', 'missing'] as any),
-			// ).rejects.toThrow("Service 'missing' not found in service discovery");
-		});
-	});
-
-	describe('has() method', () => {
-		it.skip('should return true for registered service by name - SKIPPED: requires services Map', async () => {
-			// Skipped because has() checks services Map which isn't populated by register()
-			const mockService = {
-				serviceName: 'test' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'test', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([mockService]);
-
-			// Would return false because services Map is not populated
-			// expect(discovery.has('test')).toBe(true);
-		});
-
-		it('should return false for non-registered service by name', () => {
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			expect(discovery.has('nonexistent')).toBe(false);
-		});
-
-		it.skip('should return true for registered service by instance - SKIPPED: requires services Map', async () => {
-			// Skipped because has() checks services Map
-			const mockService = {
-				serviceName: 'test' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'test', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([mockService]);
-
-			// Would return false because services Map is not populated
-			// expect(discovery.has(mockService)).toBe(true);
-		});
-
-		it('should return false for non-registered service by instance', () => {
-			const mockService = {
-				serviceName: 'test' as const,
-				async register() {
-					return { value: 1 };
-				},
-			} satisfies Service<'test', { value: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			expect(discovery.has(mockService)).toBe(false);
-		});
-	});
-
-	describe('Error Handling', () => {
-		it('should propagate errors from service registration', async () => {
-			const errorService = {
-				serviceName: 'failing' as const,
-				async register() {
-					throw new Error('Registration failed');
-				},
-			} satisfies Service<'failing', never>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			await expect(discovery.register([errorService])).rejects.toThrow(
-				'Registration failed',
-			);
-		});
-
-		it('should handle errors with custom error messages', async () => {
-			const errorService = {
-				serviceName: 'custom-error' as const,
-				async register() {
-					throw new Error('Custom error message');
-				},
-			} satisfies Service<'custom-error', never>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			await expect(discovery.register([errorService])).rejects.toThrow(
-				'Custom error message',
-			);
-		});
-
-		it('should handle synchronous errors', async () => {
-			const errorService = {
-				serviceName: 'sync-error' as const,
-				register() {
-					throw new Error('Synchronous error');
-				},
-			} satisfies Service<'sync-error', never>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-
-			await expect(discovery.register([errorService])).rejects.toThrow(
-				'Synchronous error',
-			);
-		});
-	});
-
-	describe('Service Interface', () => {
-		it('should work with class-based services', async () => {
-			class DatabaseService {
-				connected = false;
-
-				async connect() {
-					this.connected = true;
-				}
-			}
-
-			const databaseService = {
-				serviceName: 'database' as const,
-				async register() {
-					const db = new DatabaseService();
-					await db.connect();
-					return db;
-				},
-			} satisfies Service<'database', DatabaseService>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([databaseService]);
-
-			expect(services.database).toBeInstanceOf(DatabaseService);
-			expect(services.database.connected).toBe(true);
-		});
-
-		it('should work with factory functions', async () => {
-			const createCache = () => ({
-				data: new Map<string, any>(),
-				set(key: string, value: any) {
-					this.data.set(key, value);
-				},
-				get(key: string) {
-					return this.data.get(key);
-				},
-			});
-
-			const cacheService = {
-				serviceName: 'cache' as const,
-				async register() {
-					return createCache();
-				},
-			} satisfies Service<'cache', ReturnType<typeof createCache>>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([cacheService]);
-
-			services.cache.set('key', 'value');
-			expect(services.cache.get('key')).toBe('value');
-		});
-
-		it('should work with complex service dependencies', async () => {
-			const loggerService = {
-				serviceName: 'logger' as const,
-				async register() {
-					return { log: (msg: string) => msg };
-				},
-			} satisfies Service<'logger', { log: (msg: string) => string }>;
-
-			const databaseService = {
-				serviceName: 'database' as const,
-				async register(_envParser) {
-					// Service can access other services through discovery if needed
-					return { connected: true, logger: 'attached' };
-				},
-			} satisfies Service<'database', { connected: boolean; logger: string }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([
-				loggerService,
-				databaseService,
-			]);
-
-			expect(services.logger).toBeDefined();
-			expect(services.database).toBeDefined();
-			expect(services.database.connected).toBe(true);
-		});
-	});
-
-	describe('Real-world Scenarios', () => {
-		it('should handle database service pattern', async () => {
-			interface Database {
-				host: string;
-				port: number;
-				connected: boolean;
-				query: (sql: string) => Promise<any[]>;
-			}
-
-			const databaseService = {
-				serviceName: 'database' as const,
-				async register() {
-					// Create a new EnvironmentParser instance for service-specific config
-					const serviceEnv = new EnvironmentParser({ ...process.env });
-					const config = serviceEnv
-						.create((get) => ({
-							host: get('DB_HOST').string().default('localhost'),
-							port: get('DB_PORT')
-								.string()
-								.default('5432')
-								.transform((val) => Number(val)),
-						}))
-						.parse();
-
-					const db: Database = {
-						host: config.host,
-						port: config.port,
-						connected: true,
-						query: async () => [],
-					};
-
-					return db;
-				},
-			} satisfies Service<'database', Database>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([databaseService]);
-
-			expect(services.database.connected).toBe(true);
-			expect(services.database.host).toBe('localhost');
-			expect(services.database.port).toBe(5432);
-		});
-
-		it('should handle cache service pattern', async () => {
-			interface Cache {
-				get(key: string): Promise<any>;
-				set(key: string, value: any, ttl?: number): Promise<void>;
-				delete(key: string): Promise<void>;
-			}
-
-			const cacheService = {
-				serviceName: 'cache' as const,
-				async register() {
-					const storage = new Map<string, any>();
-
-					return {
-						async get(key: string) {
-							return storage.get(key);
-						},
-						async set(key: string, value: any) {
-							storage.set(key, value);
-						},
-						async delete(key: string) {
-							storage.delete(key);
-						},
-					} satisfies Cache;
-				},
-			} satisfies Service<'cache', Cache>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			const services = await discovery.register([cacheService]);
-
-			await services.cache.set('test', 'value');
-			expect(await services.cache.get('test')).toBe('value');
-
-			await services.cache.delete('test');
-			expect(await services.cache.get('test')).toBeUndefined();
-		});
-
-		it('should handle multiple service initialization in order', async () => {
-			const initOrder: string[] = [];
-
-			const service1 = {
-				serviceName: 'first' as const,
-				async register() {
-					initOrder.push('first');
-					return { order: 1 };
-				},
-			} satisfies Service<'first', { order: number }>;
-
-			const service2 = {
-				serviceName: 'second' as const,
-				async register() {
-					initOrder.push('second');
-					return { order: 2 };
-				},
-			} satisfies Service<'second', { order: number }>;
-
-			const service3 = {
-				serviceName: 'third' as const,
-				async register() {
-					initOrder.push('third');
-					return { order: 3 };
-				},
-			} satisfies Service<'third', { order: number }>;
-
-			const discovery = ServiceDiscovery.getInstance(envParser);
-			await discovery.register([service1, service2, service3]);
-
-			expect(initOrder).toEqual(['first', 'second', 'third']);
-		});
-	});
-});