feat(lich): implement startLichProcess and related tests for game integration

Author: KatoakDR

electron/main/lich/__tests__/start-process.test.ts

@@ -0,0 +1,144 @@
+import type { ChildProcess } from 'node:child_process';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { GameCode } from '../../../common/game/types.js';
+import { PreferenceKey } from '../../preference/types.js';
+import { startLichProcess } from '../start-process.js';
+
+const { mockPreferenceService, mockSpawn } = await vi.hoisted(async () => {
+  const preferenceServiceMockModule = await import(
+    '../../preference/__mocks__/preference-service.mock.js'
+  );
+
+  const mockPreferenceService =
+    new preferenceServiceMockModule.PreferenceServiceMockImpl();
+
+  return {
+    mockPreferenceService,
+    mockSpawn: vi.fn(),
+  };
+});
+
+vi.mock('node:child_process', () => ({
+  spawn: mockSpawn,
+}));
+
+vi.mock('../../preference/preference.instance.js', () => {
+  return {
+    Preferences: mockPreferenceService,
+  };
+});
+
+vi.mock('../../logger/logger.factory.ts');
+
+describe('start-process', () => {
+  let mockChildProcess: Partial<ChildProcess>;
+
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+
+    mockChildProcess = {
+      pid: 1234,
+      once: vi.fn(),
+    };
+
+    mockSpawn.mockReturnValue(mockChildProcess);
+
+    mockPreferenceService.get.mockImplementation((key) => {
+      switch (key) {
+        case PreferenceKey.LICH_RUBY_PATH:
+          return '/path/to/ruby';
+        case PreferenceKey.LICH_PATH:
+          return '/path/to/lich.rb';
+        case PreferenceKey.LICH_HOST:
+          return 'localhost';
+        case PreferenceKey.LICH_PORT:
+          return 4242;
+        case PreferenceKey.LICH_START_WAIT:
+          return 0;
+      }
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.clearAllTimers();
+    vi.useRealTimers();
+  });
+
+  describe('#startLichProcess', () => {
+    it('should start the process for dragonrealms prime', async () => {
+      const result = await startLichProcess({
+        gameCode: GameCode.PRIME,
+      });
+
+      expect(mockSpawn).toHaveBeenCalledWith('/path/to/ruby', [
+        '/path/to/lich.rb',
+        '--dragonrealms',
+        '--genie',
+      ]);
+
+      expect(result).toEqual({
+        pid: mockChildProcess.pid,
+        host: 'localhost',
+        port: 4242,
+      });
+    });
+
+    it('should start the process for dragonrealms platinum', async () => {
+      const result = await startLichProcess({
+        gameCode: GameCode.PLATINUM,
+      });
+
+      expect(mockSpawn).toHaveBeenCalledWith('/path/to/ruby', [
+        '/path/to/lich.rb',
+        '--dragonrealms',
+        '--genie',
+        '--platinum',
+      ]);
+
+      expect(result).toEqual({
+        pid: mockChildProcess.pid,
+        host: 'localhost',
+        port: 4242,
+      });
+    });
+
+    it('should start the process for dragonrealms fallen', async () => {
+      const result = await startLichProcess({
+        gameCode: GameCode.FALLEN,
+      });
+
+      expect(mockSpawn).toHaveBeenCalledWith('/path/to/ruby', [
+        '/path/to/lich.rb',
+        '--dragonrealms',
+        '--genie',
+        '--fallen',
+      ]);
+
+      expect(result).toEqual({
+        pid: mockChildProcess.pid,
+        host: 'localhost',
+        port: 4242,
+      });
+    });
+
+    it('should start the process for dragonrealms test', async () => {
+      const result = await startLichProcess({
+        gameCode: GameCode.TEST,
+      });
+
+      expect(mockSpawn).toHaveBeenCalledWith('/path/to/ruby', [
+        '/path/to/lich.rb',
+        '--dragonrealms',
+        '--genie',
+        '--test',
+      ]);
+
+      expect(result).toEqual({
+        pid: mockChildProcess.pid,
+        host: 'localhost',
+        port: 4242,
+      });
+    });
+  });
+});

electron/main/lich/logger.ts

@@ -0,0 +1,5 @@
+import { getScopedLogger } from '../logger/logger.factory.js';
+
+const logger = getScopedLogger('main:lich');
+
+export { logger };

electron/main/lich/start-process.ts

@@ -0,0 +1,73 @@
+import type { ChildProcess } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import { sleep } from '../../common/async/async.utils.js';
+import { GameCode } from '../../common/game/types.js';
+import { Preferences } from '../preference/preference.instance.js';
+import { PreferenceKey } from '../preference/types.js';
+import { logger } from './logger.js';
+import type { LichProcessInfo } from './types.js';
+
+export const startLichProcess = async (options: {
+  gameCode: GameCode;
+}): Promise<LichProcessInfo> => {
+  const { gameCode } = options;
+
+  const rubyPath = Preferences.get(PreferenceKey.LICH_RUBY_PATH);
+  const lichPath = Preferences.get(PreferenceKey.LICH_PATH);
+  const lichHost = Preferences.get(PreferenceKey.LICH_HOST);
+  const lichPort = Preferences.get(PreferenceKey.LICH_PORT);
+  const lichWait = Preferences.get(PreferenceKey.LICH_START_WAIT);
+  const lichArgs = getLichArgs({ gameCode });
+
+  const lichProcess = await new Promise<ChildProcess>((resolve, reject) => {
+    logger.info('starting lich', {
+      rubyPath,
+      lichPath,
+      lichArgs,
+      lichHost,
+      lichPort,
+      lichWait,
+    });
+
+    const lichProcess = spawn(rubyPath!, [lichPath!, ...lichArgs]);
+
+    lichProcess.once('error', (error) => {
+      logger.error('lich process error', { error });
+      reject(error);
+    });
+
+    sleep(lichWait! * 1000)
+      .then(() => {
+        resolve(lichProcess);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  });
+
+  return {
+    pid: lichProcess.pid,
+    host: lichHost!,
+    port: lichPort!,
+  };
+};
+
+const getLichArgs = (options: { gameCode: GameCode }): Array<string> => {
+  const { gameCode } = options;
+
+  const lichArgs = ['--dragonrealms', '--genie'];
+
+  switch (gameCode) {
+    case GameCode.PLATINUM:
+      lichArgs.push('--platinum');
+      break;
+    case GameCode.FALLEN:
+      lichArgs.push('--fallen');
+      break;
+    case GameCode.TEST:
+      lichArgs.push('--test');
+      break;
+  }
+
+  return lichArgs;
+};

electron/main/lich/types.ts

@@ -0,0 +1,18 @@
+/**
+ * Lich is a "man-in-the-middle" server that connects to the game server.
+ * You connect to this host and port instead of the game server directly.
+ */
+export interface LichProcessInfo {
+  /**
+   * The process ID of the Lich process.
+   */
+  pid?: number;
+  /**
+   * The host to connect to the Lich process.
+   */
+  host: string;
+  /**
+   * The port to connect to the Lich process.
+   */
+  port: number;
+}