@djodjonx/x32-simulator 0.0.1

package/tests/domain/models/OscMessage.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { OscMessage } from '../../../src/domain/models/OscMessage';
+
+describe('OscMessage', () => {
+  it('should create an instance correctly', () => {
+    const msg = new OscMessage('/test', [1, 'string', 0.5]);
+    expect(msg.address).toBe('/test');
+    expect(msg.args).toEqual([1, 'string', 0.5]);
+  });
+
+  it('should validate address prefix', () => {
+    const msg = new OscMessage('/ch/01/mix', []);
+    expect(msg.startsWith('/ch')).toBe(true);
+    expect(msg.startsWith('/bus')).toBe(false);
+  });
+
+  it('should retrieve typed arguments safely', () => {
+    const msg = new OscMessage('/test', [123, 'hello']);
+    expect(msg.getArgAsNumber(0)).toBe(123);
+    expect(msg.getArgAsString(1)).toBe('hello');
+  });
+
+  it('should throw when retrieving wrong type', () => {
+    const msg = new OscMessage('/test', [123]);
+    expect(() => msg.getArgAsString(0)).toThrow();
+  });
+
+  it('should create from packet', () => {
+    const packet = { 
+        oscType: 'message' as const, 
+        address: '/foo', 
+        args: [{ type: 'i', value: 10 }, 20] 
+    };
+    const msg = OscMessage.fromPacket(packet);
+    expect(msg.address).toBe('/foo');
+    expect(msg.args).toEqual([10, 20]);
+  });
+});

package/tests/domain/models/X32Address.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { X32Address } from '../../../src/domain/models/X32Address';
+
+describe('X32Address', () => {
+  it('should parse path correctly', () => {
+    const addr = new X32Address('/ch/01/mix/fader');
+    expect(addr.path).toBe('/ch/01/mix/fader');
+    expect(addr.root).toBe('ch');
+    expect(addr.index).toBe('01');
+    expect(addr.suffix).toBe('/mix/fader');
+  });
+
+  it('should handle short paths', () => {
+    const addr = new X32Address('/status');
+    expect(addr.root).toBe('status');
+    expect(addr.index).toBeUndefined();
+    expect(addr.suffix).toBe('');
+  });
+
+  it('should match category', () => {
+    const addr = new X32Address('/ch/01');
+    expect(addr.isCategory('ch')).toBe(true);
+    expect(addr.isCategory('bus')).toBe(false);
+  });
+
+  it('should match regex pattern', () => {
+    const addr = new X32Address('/ch/01/mix/on');
+    expect(addr.matches(/^\/ch\/\d+\/mix\/on$/)).toBe(true);
+  });
+});

package/tests/domain/models/X32Node.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { X32Node } from '../../../src/domain/models/X32Node';
+
+describe('X32Node', () => {
+  it('should validate float types', () => {
+    const node = new X32Node('f', 0.0);
+    expect(node.validate(0.5)).toBe(true);
+    expect(node.validate(1)).toBe(true);
+    expect(node.validate('0.5')).toBe(false);
+  });
+
+  it('should validate int types', () => {
+    const node = new X32Node('i', 0);
+    expect(node.validate(1)).toBe(true);
+    expect(node.validate(1.5)).toBe(true); // JS numbers are floats, simulation logic accepts it
+    expect(node.validate('1')).toBe(false);
+  });
+
+  it('should validate string types', () => {
+    const node = new X32Node('s', '');
+    expect(node.validate('text')).toBe(true);
+    expect(node.validate(123)).toBe(false);
+  });
+
+  it('should create from factory', () => {
+    const node = X32Node.from({ type: 'i', default: 1 });
+    expect(node.type).toBe('i');
+    expect(node.default).toBe(1);
+  });
+});

package/tests/domain/services/MeterService.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { MeterService } from '../../../src/domain/services/MeterService';
+import { X32State } from '../../../src/domain/entities/X32State';
+import { X32Node } from '../../../src/domain/models/X32Node';
+
+describe('MeterService', () => {
+  it('should generate meter data with noise floor', () => {
+    const service = new MeterService();
+    // /meters/0 has 70 meters
+    const data = service.generateMeterData('/meters/0');
+    expect(data.path).toBe('/meters/0');
+    expect(data.values).toHaveLength(70);
+    // Expect small random values
+    expect(data.values[0]).toBeGreaterThanOrEqual(0);
+    expect(data.values[0]).toBeLessThan(0.06);
+  });
+
+  it('should simulate fader signal', () => {
+    const service = new MeterService();
+    const state = new X32State({ '/ch/01/mix/fader': new X32Node('f', 0.0) });
+    state.set('/ch/01/mix/fader', 0.8);
+
+    const data = service.generateMeterData('/meters/1', state);
+    // Meter 1 corresponds to CH 01
+    expect(data.values[0]).toBeGreaterThan(0.5); // Should reflect fader level
+  });
+});

package/tests/domain/services/OscMessageHandler.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OscMessageHandler } from '../../../src/domain/services/OscMessageHandler';
+import { X32State } from '../../../src/domain/entities/X32State';
+import { SubscriptionManager } from '../../../src/domain/entities/SubscriptionManager';
+import { MeterService } from '../../../src/domain/services/MeterService';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { StaticResponseService } from '../../../src/domain/services/StaticResponseService';
+import { ILogger } from '../../../src/domain/ports/ILogger';
+
+describe('OscMessageHandler', () => {
+  let handler: OscMessageHandler;
+  let state: X32State;
+  let subManager: SubscriptionManager;
+  let logger: ILogger;
+
+  beforeEach(() => {
+    state = new X32State({});
+    logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    subManager = new SubscriptionManager(logger);
+    const meterService = new MeterService();
+    const schemaRegistry = {
+        has: vi.fn().mockReturnValue(false),
+        getNode: vi.fn(),
+        getAllPaths: vi.fn().mockReturnValue([])
+    } as unknown as SchemaRegistry;
+    const staticResponseService = new StaticResponseService();
+
+    handler = new OscMessageHandler(
+      state,
+      subManager,
+      logger,
+      '127.0.0.1',
+      'Mixer',
+      'X32',
+      meterService,
+      schemaRegistry,
+      staticResponseService
+    );
+  });
+
+  it('should dispatch /status to StaticResponseStrategy', () => {
+    const replies = handler.handle({ address: '/status', args: [] }, { address: '1.2.3.4', port: 1234 });
+    expect(replies).toHaveLength(1);
+    expect(replies[0].address).toBe('/status');
+  });
+
+  it('should warn on unknown command', () => {
+    handler.handle({ address: '/unknown', args: [] }, { address: '1.2.3.4', port: 1234 });
+    expect(logger.warn).toHaveBeenCalled();
+  });
+});

package/tests/domain/services/SchemaRegistry.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { SchemaFactory } from '../../../src/domain/services/SchemaFactory';
+
+describe('SchemaRegistry', () => {
+  const factory = new SchemaFactory();
+  const registry = new SchemaRegistry(factory);
+
+  it('should load full schema', () => {
+    const schema = registry.getSchema();
+    expect(Object.keys(schema).length).toBeGreaterThan(1000);
+  });
+
+  it('should find specific nodes', () => {
+    const node = registry.getNode('/ch/01/mix/fader');
+    expect(node).toBeDefined();
+    expect(node?.type).toBe('f');
+  });
+
+  it('should map index to root', () => {
+    expect(registry.getRootFromIndex(0)).toBe('/ch/01');
+    expect(registry.getRootFromIndex(31)).toBe('/ch/32');
+    expect(registry.getRootFromIndex(32)).toBe('/auxin/01');
+    expect(registry.getRootFromIndex(39)).toBe('/auxin/08');
+    expect(registry.getRootFromIndex(40)).toBe('/fxrtn/01');
+    expect(registry.getRootFromIndex(47)).toBe('/fxrtn/08');
+    expect(registry.getRootFromIndex(48)).toBe('/bus/01');
+    expect(registry.getRootFromIndex(63)).toBe('/bus/16');
+    expect(registry.getRootFromIndex(64)).toBe('/mtx/01');
+    expect(registry.getRootFromIndex(69)).toBe('/mtx/06');
+    expect(registry.getRootFromIndex(70)).toBe('/main/st');
+    expect(registry.getRootFromIndex(71)).toBe('/main/m');
+    expect(registry.getRootFromIndex(72)).toBe('/dca/01');
+    expect(registry.getRootFromIndex(79)).toBe('/dca/08');
+    expect(registry.getRootFromIndex(80)).toBeNull();
+  });
+
+  it('should check if path exists', () => {
+    expect(registry.has('/ch/01/mix/fader')).toBe(true);
+    expect(registry.has('/non/existent')).toBe(false);
+  });
+
+  it('should return all paths', () => {
+    const paths = registry.getAllPaths();
+    expect(paths).toContain('/ch/01/mix/fader');
+  });
+});

package/tests/domain/services/StaticResponseService.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { StaticResponseService } from '../../../src/domain/services/StaticResponseService';
+
+describe('StaticResponseService', () => {
+  it('should return static data', () => {
+    const service = new StaticResponseService();
+    const resp = service.getResponse('/status');
+    expect(resp).toEqual(['active', '{{ip}}', '{{name}}']);
+  });
+
+  it('should return undefined for unknown path', () => {
+    const service = new StaticResponseService();
+    expect(service.getResponse('/unknown')).toBeUndefined();
+  });
+});

package/tests/domain/services/strategies/BatchStrategy.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BatchStrategy } from '../../../../src/domain/services/strategies/BatchStrategy';
+import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
+
+describe('BatchStrategy', () => {
+  it('should handle /formatsubscribe', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const strategy = new BatchStrategy(manager, logger);
+
+    // /formatsubscribe, alias, pattern, start, end, factor
+    strategy.execute({ address: '/formatsubscribe', args: ['alias', '/ch/*/mix/on', 1, 10, 5] }, { address: '1.2.3.4', port: 1234 });
+    expect(manager.getSubscribers()).toHaveLength(1);
+    expect(manager.getSubscribers()[0].type).toBe('format');
+  });
+
+  it('should handle /batchsubscribe', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const strategy = new BatchStrategy(manager, logger);
+
+    // /batchsubscribe, alias, path1, path2, ..., int1, int2, ..., factor
+    // args: ['alias', '/mix/fader', '/mix/on', 10] (factor=10)
+    strategy.execute({ address: '/batchsubscribe', args: ['b_alias', '/mix/fader', '/mix/on', 10] }, { address: '1.2.3.4', port: 1234 });
+    
+    const subs = manager.getSubscribers();
+    expect(subs).toHaveLength(1);
+    expect(subs[0].type).toBe('batch');
+    expect(subs[0].paths).toEqual(['/mix/fader', '/mix/on']);
+    expect(subs[0].factor).toBe(10);
+  });
+
+  it('should return empty if no integer found in batchsubscribe', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const strategy = new BatchStrategy(manager, logger);
+
+    const replies = strategy.execute({ address: '/batchsubscribe', args: ['alias', 'path'] }, { address: '1.2.3.4', port: 1234 });
+    expect(replies).toHaveLength(0);
+  });
+});

package/tests/domain/services/strategies/MeterStrategy.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect, vi } from 'vitest';
+import { MeterStrategy } from '../../../../src/domain/services/strategies/MeterStrategy';
+import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
+import { MeterService } from '../../../../src/domain/services/MeterService';
+import { X32State } from '../../../../src/domain/entities/X32State';
+
+describe('MeterStrategy', () => {
+  it('should handle /meters', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const meterService = new MeterService();
+    const state = new X32State({});
+    const strategy = new MeterStrategy(manager, state, meterService);
+
+    strategy.execute({ address: '/meters', args: ['/meters/1'] }, { address: '1.2.3.4', port: 1234 });
+    expect(manager.getSubscribers()).toHaveLength(1);
+    expect(manager.getSubscribers()[0].type).toBe('meter');
+  });
+});

package/tests/domain/services/strategies/NodeDiscoveryStrategy.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { NodeDiscoveryStrategy } from '../../../../src/domain/services/strategies/NodeDiscoveryStrategy';
+import { SchemaRegistry } from '../../../../src/domain/services/SchemaRegistry';
+
+describe('NodeDiscoveryStrategy', () => {
+  it('should list children', () => {
+    // Mock registry with getAllPaths
+    const registry = {
+        getAllPaths: () => ['/ch/01/mix', '/ch/01/config', '/bus/01']
+    } as unknown as SchemaRegistry;
+
+    const strategy = new NodeDiscoveryStrategy(registry);
+    
+    // Query /ch/01
+    const replies = strategy.execute({ address: '/node', args: ['/ch/01'] }, { address: '127.0.0.1', port: 10000 });
+    
+    expect(replies).toHaveLength(1);
+    expect(replies[0].args).toContain('mix');
+    expect(replies[0].args).toContain('config');
+    expect(replies[0].args).not.toContain('bus');
+  });
+});

package/tests/domain/services/strategies/StateAccessStrategy.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { StateAccessStrategy } from '../../../../src/domain/services/strategies/StateAccessStrategy';
+import { X32State } from '../../../../src/domain/entities/X32State';
+import { SchemaRegistry } from '../../../../src/domain/services/SchemaRegistry';
+import { X32Node } from '../../../../src/domain/models/X32Node';
+
+describe('StateAccessStrategy', () => {
+  let strategy: StateAccessStrategy;
+  let state: X32State;
+  
+  beforeEach(() => {
+    // Mini schema for testing
+    const schema = {
+        '/test/fader': new X32Node('f', 0.0),
+        '/config/mute/1': new X32Node('i', 0),
+    };
+    
+    // Mock registry to return our mini schema nodes
+    const registry = {
+        has: (path: string) => path in schema,
+        getNode: (path: string) => schema[path as keyof typeof schema]
+    } as unknown as SchemaRegistry;
+
+    state = new X32State(schema);
+    
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    
+    strategy = new StateAccessStrategy(state, logger, registry);
+  });
+
+  it('should handle get requests', () => {
+    state.set('/test/fader', 0.5);
+    const replies = strategy.execute({ address: '/test/fader', args: [] }, { address: '127.0.0.1', port: 10000 });
+    expect(replies).toHaveLength(1);
+    expect(replies[0].args[0]).toBe(0.5);
+  });
+
+  it('should handle set requests', () => {
+    const replies = strategy.execute({ address: '/test/fader', args: [0.8] }, { address: '127.0.0.1', port: 10000 });
+    expect(state.get('/test/fader')).toBe(0.8);
+    expect(replies).toHaveLength(0);
+  });
+
+  it('should validate types', () => {
+    // Sending string to float
+    strategy.execute({ address: '/test/fader', args: ['invalid'] }, { address: '127.0.0.1', port: 10000 });
+    expect(state.get('/test/fader')).toBe(0.0); // Should not change
+  });
+});

package/tests/domain/services/strategies/StaticResponseStrategy.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { StaticResponseStrategy } from '../../../../src/domain/services/strategies/StaticResponseStrategy';
+import { StaticResponseService } from '../../../../src/domain/services/StaticResponseService';
+
+describe('StaticResponseStrategy', () => {
+  it('should return static response with replacements', () => {
+    const service = new StaticResponseService();
+    const strategy = new StaticResponseStrategy('10.0.0.1', 'MyMixer', 'X32', service);
+    
+    // /status -> ["active", "{{ip}}", "{{name}}"]
+    const replies = strategy.execute({ address: '/status', args: [] }, { address: '127.0.0.1', port: 10000 });
+    
+    expect(replies[0].args).toEqual(['active', '10.0.0.1', 'MyMixer']);
+  });
+});

package/tests/domain/services/strategies/SubscriptionStrategy.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SubscriptionStrategy } from '../../../../src/domain/services/strategies/SubscriptionStrategy';
+import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
+import { X32State } from '../../../../src/domain/entities/X32State';
+import { X32Node } from '../../../../src/domain/models/X32Node';
+
+describe('SubscriptionStrategy', () => {
+  it('should handle /subscribe', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const state = new X32State({ '/test': new X32Node('i', 123) });
+    const strategy = new SubscriptionStrategy(manager, state, logger);
+
+    const replies = strategy.execute({ address: '/subscribe', args: ['/test', 10] }, { address: '1.2.3.4', port: 1234 });
+    
+    // Should add subscriber
+    expect(manager.getSubscribers()).toHaveLength(1);
+    // Should return current value
+    expect(replies[0].args[0]).toBe(123);
+  });
+
+  it('should handle /xremote', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const state = new X32State({});
+    const strategy = new SubscriptionStrategy(manager, state, logger);
+
+    strategy.execute({ address: '/xremote', args: [] }, { address: '1.2.3.4', port: 1234 });
+    expect(manager.getSubscribers()).toHaveLength(1);
+  });
+
+  it('should handle /unsubscribe', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const state = new X32State({});
+    const strategy = new SubscriptionStrategy(manager, state, logger);
+    const client = { address: '1.2.3.4', port: 1234 };
+
+    manager.addPathSubscriber(client, '/test');
+    expect(manager.getSubscribers()).toHaveLength(1);
+
+    strategy.execute({ address: '/unsubscribe', args: ['/test'] }, client);
+    expect(manager.getSubscribers()).toHaveLength(0);
+  });
+});

package/tests/infrastructure/mappers/OscCodec.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { OscCodec } from '../../../src/infrastructure/mappers/OscCodec';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { X32Node } from '../../../src/domain/models/X32Node';
+
+describe('OscCodec', () => {
+  const registry = {
+      getNode: (path: string) => {
+          if (path === '/test/int') return new X32Node('i', 0);
+          if (path === '/test/float') return new X32Node('f', 0.0);
+          if (path === '/test/string') return new X32Node('s', '');
+          return undefined;
+      }
+  } as unknown as SchemaRegistry;
+
+  const codec = new OscCodec(registry);
+
+  it('should encode message with schema inference', () => {
+      // Int
+      const buf1 = codec.encode('/test/int', [123]);
+      expect(Buffer.isBuffer(buf1)).toBe(true);
+      
+      // Float
+      const buf2 = codec.encode('/test/float', [0.5]);
+      expect(Buffer.isBuffer(buf2)).toBe(true);
+
+      // String
+      const buf3 = codec.encode('/test/string', ['hello']);
+      expect(Buffer.isBuffer(buf3)).toBe(true);
+  });
+
+  it('should handle raw typed args in encode', () => {
+      const buf = codec.encode('/any', [{ type: 'i', value: 10 }]);
+      expect(Buffer.isBuffer(buf)).toBe(true);
+  });
+
+  it('should handle buffers in encode', () => {
+      const buf = codec.encode('/any', [Buffer.alloc(4)]);
+      expect(Buffer.isBuffer(buf)).toBe(true);
+  });
+});

package/tests/infrastructure/repositories/InMemoryStateRepository.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi } from 'vitest';
+import { InMemoryStateRepository } from '../../../src/infrastructure/repositories/InMemoryStateRepository';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { ILogger } from '../../../src/domain/ports/ILogger';
+
+describe('InMemoryStateRepository', () => {
+  it('should initialize and provide state', () => {
+    const logger: ILogger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const schemaRegistry = {
+        getSchema: vi.fn().mockReturnValue({})
+    } as unknown as SchemaRegistry;
+
+    const repo = new InMemoryStateRepository(logger, schemaRegistry);
+    const state = repo.getState();
+    
+    expect(state).toBeDefined();
+    expect(repo.getState()).toBe(state); // Singleton check
+  });
+
+  it('should reset state', () => {
+    const logger: ILogger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const schemaRegistry = { getSchema: vi.fn().mockReturnValue({}) } as unknown as SchemaRegistry;
+    const repo = new InMemoryStateRepository(logger, schemaRegistry);
+    
+    // We can't easily see internal reset without mocking X32State, 
+    // but we can verify it doesn't throw.
+    expect(() => repo.reset()).not.toThrow();
+  });
+});

package/tests/infrastructure/services/ConsoleLogger.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ConsoleLogger, LogLevel } from '../../../src/infrastructure/services/ConsoleLogger';
+import { LogCategory } from '../../../src/domain/ports/ILogger';
+
+describe('ConsoleLogger', () => {
+  let logger: ConsoleLogger;
+
+  beforeEach(() => {
+    logger = new ConsoleLogger();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.clearAllMocks();
+  });
+
+  it('should log messages at all levels', () => {
+    logger.setLevel(LogLevel.DEBUG);
+    logger.debug(LogCategory.SYSTEM, 'debug');
+    logger.info(LogCategory.SYSTEM, 'info');
+    logger.warn(LogCategory.SYSTEM, 'warn');
+    logger.error(LogCategory.SYSTEM, 'error');
+    expect(console.log).toHaveBeenCalledTimes(4);
+  });
+
+  it('should not log if level is higher', () => {
+    logger.setLevel(LogLevel.ERROR);
+    logger.info(LogCategory.SYSTEM, 'test info');
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('should format message with color codes', () => {
+    logger.setLevel(LogLevel.INFO);
+    logger.info(LogCategory.SYSTEM, 'hello');
+    const call = vi.mocked(console.log).mock.calls[0][0];
+    expect(call).toContain('[SYSTEM  ]');
+    expect(call).toContain('hello');
+  });
+
+  it('should handle data metadata', () => {
+    logger.info(LogCategory.SYSTEM, 'msg', { foo: 'bar' });
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('{"foo":"bar"}'));
+    
+    // Buffer data
+    logger.info(LogCategory.SYSTEM, 'buf', Buffer.from('abc'));
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('<Buffer 3b>'));
+  });
+
+  it('should enable and disable categories', () => {
+    logger.disableCategory(LogCategory.SYSTEM);
+    logger.info(LogCategory.SYSTEM, 'hidden');
+    expect(console.log).not.toHaveBeenCalled();
+
+    logger.enableCategory(LogCategory.SYSTEM);
+    logger.info(LogCategory.SYSTEM, 'shown');
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('should singleton instance', () => {
+    const instance = ConsoleLogger.getInstance();
+    expect(instance).toBeInstanceOf(ConsoleLogger);
+    expect(ConsoleLogger.getInstance()).toBe(instance);
+  });
+
+  it('should hide messages matching patterns', () => {
+    process.env.HIDDEN_LOG = 'secret,private';
+    const loggerWithEnv = new ConsoleLogger();
+    
+    loggerWithEnv.info(LogCategory.SYSTEM, 'this is secret');
+    expect(console.log).not.toHaveBeenCalled();
+
+    loggerWithEnv.info(LogCategory.SYSTEM, 'this is public');
+    expect(console.log).toHaveBeenCalled();
+    
+    delete process.env.HIDDEN_LOG;
+  });
+});

package/tests/infrastructure/services/UdpNetworkGateway.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { UdpNetworkGateway } from '../../../src/infrastructure/services/UdpNetworkGateway';
+import { ILogger } from '../../../src/domain/ports/ILogger';
+import { OscCodec } from '../../../src/infrastructure/mappers/OscCodec';
+import * as dgram from 'dgram';
+
+let messageCallback: Function;
+
+vi.mock('dgram', () => ({
+    createSocket: vi.fn(() => ({
+        bind: vi.fn((port, ip, cb) => cb && cb()),
+        on: vi.fn((event, cb) => {
+            if (event === 'message') messageCallback = cb;
+        }),
+        send: vi.fn(),
+        close: vi.fn((cb) => cb && cb()),
+    }))
+}));
+
+describe('UdpNetworkGateway', () => {
+  let gateway: UdpNetworkGateway;
+  let logger: ILogger;
+  let codec: OscCodec;
+
+  beforeEach(() => {
+    logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    codec = { 
+        encode: vi.fn().mockReturnValue(Buffer.from('encoded')),
+        decode: vi.fn().mockReturnValue({ address: '/decoded', args: [] })
+    } as unknown as OscCodec;
+    gateway = new UdpNetworkGateway(logger, codec);
+  });
+
+  it('should start and bind socket', async () => {
+    await gateway.start(10023, '0.0.0.0');
+    expect(dgram.createSocket).toHaveBeenCalledWith('udp4');
+  });
+
+  it('should send packets', async () => {
+    await gateway.start(10023, '0.0.0.0');
+    gateway.send({ address: '1.2.3.4', port: 1234 }, '/test', [1]);
+    expect(codec.encode).toHaveBeenCalledWith('/test', [1]);
+  });
+
+  it('should receive and decode packets', async () => {
+    const spy = vi.fn();
+    gateway.onPacket(spy);
+    await gateway.start(10023, '0.0.0.0');
+    
+    // Simulate incoming message
+    messageCallback(Buffer.from('raw'), { address: '5.6.7.8', port: 5678 });
+    
+    expect(codec.decode).toHaveBeenCalled();
+    expect(spy).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ address: '5.6.7.8' }));
+  });
+
+  it('should stop', async () => {
+    await gateway.start(10023, '0.0.0.0');
+    await gateway.stop();
+  });
+});