@djodjonx/x32-simulator 0.0.1

package/tests/presentation/cli/server.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+
+const mocks = vi.hoisted(() => ({
+    serviceInstance: {
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        resetState: vi.fn()
+    },
+    rl: {
+        on: vi.fn(),
+        close: vi.fn()
+    }
+}));
+
+// Mock fs
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn()
+}));
+
+// Mock SimulationService
+vi.mock('../../../src/application/use-cases/SimulationService', () => {
+    const MockService = vi.fn();
+    MockService.prototype.start = mocks.serviceInstance.start;
+    MockService.prototype.stop = mocks.serviceInstance.stop;
+    MockService.prototype.resetState = mocks.serviceInstance.resetState;
+    return {
+        SimulationService: MockService
+    };
+});
+
+// Mock ConsoleLogger
+vi.mock('../../../src/infrastructure/services/ConsoleLogger', () => ({
+    ConsoleLogger: {
+        getInstance: vi.fn().mockReturnValue({ setLevel: vi.fn() })
+    },
+    LogLevel: { DEBUG: 0 }
+}));
+
+// Mock readline
+vi.mock('readline', () => ({
+    createInterface: vi.fn().mockReturnValue(mocks.rl)
+}));
+
+import * as Server from '../../../src/presentation/cli/server';
+import { SimulationService } from '../../../src/application/use-cases/SimulationService';
+
+describe('CLI Server', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, 'log').mockImplementation(() => {});
+        vi.spyOn(console, 'error').mockImplementation(() => {});
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
+        vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+        vi.spyOn(process, 'on').mockImplementation(() => process);
+        
+        // Reset specific mock implementations if needed
+        mocks.serviceInstance.start.mockResolvedValue(undefined);
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe('parseArgs', () => {
+        it('should parse port and host flags', () => {
+            const args = ['node', 'server.ts', '--port', '1234', '--host', '1.2.3.4'];
+            const result = Server.parseArgs(args);
+            expect(result.PORT).toBe(1234);
+            expect(result.HOST).toBe('1.2.3.4');
+        });
+
+        it('should parse short flags', () => {
+            const args = ['node', 'server.ts', '-p', '1234', '-h', '1.2.3.4'];
+            const result = Server.parseArgs(args);
+            expect(result.PORT).toBe(1234);
+            expect(result.HOST).toBe('1.2.3.4');
+        });
+
+        it('should parse positional arguments', () => {
+            const args = ['node', 'server.ts', '1.2.3.4', '1234'];
+            const result = Server.parseArgs(args);
+            expect(result.PORT).toBe(1234);
+            expect(result.HOST).toBe('1.2.3.4');
+        });
+
+        it('should use defaults', () => {
+            const args = ['node', 'server.ts'];
+            const result = Server.parseArgs(args);
+            expect(result.PORT).toBe(10023);
+            expect(result.HOST).toBe('0.0.0.0');
+        });
+    });
+
+    describe('loadEnv', () => {
+        it('should load .env file', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('X32_PORT=9999\nX32_IP=10.0.0.1');
+            
+            Server.loadEnv();
+            
+            expect(process.env.X32_PORT).toBe('9999');
+            expect(process.env.X32_IP).toBe('10.0.0.1');
+            
+            delete process.env.X32_PORT;
+            delete process.env.X32_IP;
+        });
+
+        it('should handle errors gracefully', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockImplementation(() => { throw new Error('Fail'); });
+            
+            Server.loadEnv();
+            
+            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to load'), expect.any(String));
+        });
+    });
+
+    describe('bootstrap', () => {
+        it('should start simulation service', async () => {
+            await Server.bootstrap();
+            expect(SimulationService).toHaveBeenCalled();
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('X32 SIMULATION SERVER ACTIVE'));
+        });
+
+        it('should handle EADDRNOTAVAIL error', async () => {
+            const error = new Error('Bind failed');
+            (error as any).code = 'EADDRNOTAVAIL';
+            mocks.serviceInstance.start.mockRejectedValueOnce(error);
+
+            // Mock platform
+            Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
+
+            await Server.bootstrap();
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('FAILED TO BIND'));
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+
+        it('should handle generic startup errors', async () => {
+            mocks.serviceInstance.start.mockRejectedValueOnce(new Error('Generic fail'));
+            await Server.bootstrap();
+            expect(console.error).toHaveBeenCalledWith('Failed to start server:', expect.any(Error));
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+
+        it('should handle CLI commands', async () => {
+            await Server.bootstrap();
+            
+            const lineHandler = mocks.rl.on.mock.calls.find(call => call[0] === 'line')?.[1];
+            expect(lineHandler).toBeDefined();
+
+            await lineHandler('reset');
+            expect(mocks.serviceInstance.resetState).toHaveBeenCalled();
+
+            await lineHandler('stop');
+            expect(mocks.serviceInstance.stop).toHaveBeenCalled();
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+
+        it('should handle unknown CLI commands', async () => {
+            await Server.bootstrap();
+            const lineHandler = mocks.rl.on.mock.calls.find(call => call[0] === 'line')?.[1];
+            await lineHandler('unknown');
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Unknown command'));
+        });
+
+        it('should handle SIGINT', async () => {
+            await Server.bootstrap();
+            const sigintHandler = vi.mocked(process.on).mock.calls.find(call => call[0] === 'SIGINT')?.[1] as Function;
+            expect(sigintHandler).toBeDefined();
+            
+            await sigintHandler();
+            expect(mocks.serviceInstance.stop).toHaveBeenCalled();
+            expect(process.exit).toHaveBeenCalledWith(0);
+        });
+    });
+});

package/tests/presentation/library/library.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from 'vitest';
+import * as Lib from '../../../src/presentation/library/library';
+
+describe('Library Entry', () => {
+  it('should export all public members', () => {
+    expect(Lib.SimulationService).toBeDefined();
+    expect(Lib.ConsoleLogger).toBeDefined();
+    expect(Lib.UdpNetworkGateway).toBeDefined();
+    expect(Lib.InMemoryStateRepository).toBeDefined();
+    expect(Lib.LogCategory).toBeDefined();
+    // Types aren't runtime values, so we can't check them with toBeDefined(), but the import * works.
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ESNext", "DOM"],
+    "strict": true,
+    "declaration": true,
+    "removeComments": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsdown.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  clean: true,
+  dts: true,
+  entry: {
+    index: 'src/presentation/library/library.ts',
+    server: 'src/presentation/cli/server.ts',
+  },
+  format: ['cjs', 'esm'],
+  platform: 'node',
+  // Bundle all dependencies
+  // @ts-ignore
+  noExternal: [/(.*)/],
+});

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    include: ['tests/**/*.test.ts'],
+  },
+});