test: add unit tests for RestApi, Tray, and Updater modules

- Created tests for RestApiModule and RestApiService to verify
  metadata registration and API response handling.
- Added tests for TrayModule and TrayService to ensure correct
  menu setup and destruction.
- Implemented tests for UpdaterModule and related services to
  validate update checks and notifications.
- Organized all test files into a structured __tests__ directory
  mirroring the source code structure.

Author: trae-op

package.json

@@ -20,7 +20,7 @@
     "preview": "vite preview",
     "test:e2e": "playwright test",
     "test:unit:renderer": "vitest src/renderer --watch=false",
-    "test:unit:main": "vitest src/main --watch=false",
+    "test:unit:main": "vitest --config vitest.config.main.ts --watch=false",
     "check:port": "netstat -aon | findstr :8844",
     "free:port": "tasklist /fi \"PID eq 19680\" ; taskkill /PID 19680 /F",
     "open:mac:prod": "./dist/mac/reminder.app/Contents/MacOS/reminder",

src/main/@shared/error-messages.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { showErrorMessages } from "./error-messages.js";
+
+vi.mock("electron", () => ({
+  dialog: {
+    showMessageBox: vi.fn(),
+  },
+}));
+
+vi.mock("./logger.js", () => ({
+  logger: {
+    error: vi.fn(),
+  },
+}));
+
+describe("@shared/error-messages", () => {
+  it("logs error and shows dialog by default", async () => {
+    showErrorMessages({ title: "Oops", body: "Something failed" });
+
+    const { dialog } = await import("electron");
+    const { logger } = await import("./logger.js");
+
+    expect(logger.error).toHaveBeenCalledWith("Oops", "Something failed");
+    expect(dialog.showMessageBox).toHaveBeenCalledWith({
+      title: "Oops",
+      message: "Something failed",
+    });
+  });
+
+  it("logs error without showing dialog when isDialog is false", async () => {
+    showErrorMessages({ title: "Oops", body: "Hidden", isDialog: false });
+
+    const { dialog } = await import("electron");
+    const { logger } = await import("./logger.js");
+
+    expect(logger.error).toHaveBeenCalledWith("Oops", "Hidden");
+    expect(dialog.showMessageBox).not.toHaveBeenCalled();
+  });
+});

src/main/@shared/ipc/ipc.test.ts

@@ -0,0 +1,88 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ipcMainHandle, ipcMainOn, validateEventFrame } from "./ipc.js";
+
+vi.mock("electron", () => ({
+  ipcMain: {
+    handle: vi.fn(),
+    on: vi.fn(),
+  },
+}));
+
+describe("@shared/ipc", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("ipcMainHandle", () => {
+    it("registers handler and validates frame", async () => {
+      const handler = vi.fn().mockResolvedValue({ ok: true });
+      const mockFrame = { url: "file:///window:main#/" };
+      const event = { senderFrame: mockFrame };
+
+      ipcMainHandle("getAppVersion", handler);
+
+      const { ipcMain } = await import("electron");
+      const registeredHandler = vi.mocked(ipcMain.handle).mock.calls[0][1];
+
+      const result = await registeredHandler(event, "payload");
+
+      expect(handler).toHaveBeenCalledWith("payload");
+      expect(result).toEqual({ ok: true });
+    });
+
+    it("throws when frame is null", async () => {
+      const handler = vi.fn();
+      const event = { senderFrame: null };
+
+      ipcMainHandle("getAppVersion", handler);
+
+      const { ipcMain } = await import("electron");
+      const registeredHandler = vi.mocked(ipcMain.handle).mock.calls[0][1];
+
+      await expect(registeredHandler(event, undefined)).rejects.toThrow(
+        "Invalid frame: Frame is null",
+      );
+    });
+  });
+
+  describe("ipcMainOn", () => {
+    it("registers channel and calls callback", async () => {
+      const callback = vi.fn();
+
+      ipcMainOn("logout", callback);
+
+      const { ipcMain } = await import("electron");
+      const registeredHandler = vi.mocked(ipcMain.on).mock.calls[0][1];
+      const event = { reply: vi.fn() } as any;
+
+      registeredHandler(event, { id: "123" });
+
+      expect(callback).toHaveBeenCalledWith(event, { id: "123" });
+    });
+  });
+
+  describe("validateEventFrame", () => {
+    it("allows file protocol frames with hash", () => {
+      const frame = { url: "file:///window:main#/" } as any;
+
+      expect(() => validateEventFrame(frame)).not.toThrow();
+    });
+
+    it("allows localhost in development", () => {
+      process.env.NODE_ENV = "development";
+      process.env.LOCALHOST_ELECTRON_SERVER_PORT = "8844";
+      const frame = { url: "http://localhost:8844/" } as any;
+
+      expect(() => validateEventFrame(frame)).not.toThrow();
+    });
+
+    it("rejects unauthorized frames", () => {
+      const frame = { url: "https://evil.com/" } as any;
+
+      expect(() => validateEventFrame(frame)).toThrow(
+        "The event is from an unauthorized frame",
+      );
+    });
+  });
+});

src/main/@shared/logger.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from "vitest";
+
+type TTransport = {
+  format?: string;
+  level?: string;
+  maxSize?: number;
+};
+
+describe("@shared/logger", () => {
+  it("configures transports for development", async () => {
+    process.env.NODE_ENV = "development";
+    vi.resetModules();
+
+    const fileTransport: TTransport = {};
+    const consoleTransport: TTransport = {};
+
+    vi.doMock("electron-log", () => ({
+      default: {
+        info: vi.fn(),
+        transports: {
+          file: fileTransport,
+          console: consoleTransport,
+        },
+      },
+    }));
+
+    const { logger } = await import("./logger.js");
+
+    expect(logger).toBeDefined();
+    expect(fileTransport.level).toBe("info");
+    expect(consoleTransport.level).toBe("debug");
+    expect(fileTransport.maxSize).toBe(5 * 1024 * 1024);
+  });
+
+  it("configures transports for production", async () => {
+    process.env.NODE_ENV = "production";
+    vi.resetModules();
+
+    const fileTransport: TTransport = {};
+    const consoleTransport: TTransport = {};
+
+    vi.doMock("electron-log", () => ({
+      default: {
+        info: vi.fn(),
+        transports: {
+          file: fileTransport,
+          console: consoleTransport,
+        },
+      },
+    }));
+
+    const { logger } = await import("./logger.js");
+
+    expect(logger).toBeDefined();
+    expect(fileTransport.level).toBe("info");
+    expect(consoleTransport.level).toBe("info");
+  });
+});

src/main/@shared/path-resolver.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("electron", () => ({
+  app: {
+    getAppPath: vi.fn(() => "/app"),
+  },
+}));
+
+vi.mock("./utils.js", () => ({
+  isDev: vi.fn(() => false),
+}));
+
+describe("@shared/path-resolver", () => {
+  it("resolves preload path for production", async () => {
+    vi.resetModules();
+    const { getPreloadPath } = await import("./path-resolver.js");
+    expect(getPreloadPath()).toBe("/dist-main/preload.cjs");
+  });
+
+  it("resolves UI path", async () => {
+    vi.resetModules();
+    const { getUIPath } = await import("./path-resolver.js");
+    expect(getUIPath()).toBe("/app/dist-renderer/index.html");
+  });
+
+  it("resolves assets path for development", async () => {
+    vi.resetModules();
+    const { isDev } = await import("./utils.js");
+    vi.mocked(isDev).mockReturnValue(true);
+
+    const { getAssetsPath } = await import("./path-resolver.js");
+    expect(getAssetsPath()).toBe("/app/src/assets");
+  });
+});

src/main/@shared/store.test.ts

@@ -0,0 +1,66 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  clearElectronStorage,
+  clearStore,
+  deleteFromElectronStorage,
+  deleteStore,
+  getElectronStorage,
+  getStore,
+  hasElectronStorage,
+  hasStore,
+  setElectronStorage,
+  setStore,
+} from "./store.js";
+
+describe("@shared/store", () => {
+  beforeEach(() => {
+    clearStore();
+  });
+
+  describe("in-memory store", () => {
+    it("sets and gets values", () => {
+      setStore("testKey", "testValue");
+      expect(getStore("testKey")).toBe("testValue");
+    });
+
+    it("checks if a key exists", () => {
+      setStore("testKey", "value");
+      expect(hasStore("testKey")).toBe(true);
+      expect(hasStore("missingKey")).toBe(false);
+    });
+
+    it("deletes values", () => {
+      setStore("testKey", "value");
+      deleteStore("testKey");
+      expect(hasStore("testKey")).toBe(false);
+    });
+
+    it("clears all values", () => {
+      setStore("key1", "value1");
+      setStore("key2", "value2");
+      clearStore();
+      expect(hasStore("key1")).toBe(false);
+      expect(hasStore("key2")).toBe(false);
+    });
+  });
+
+  describe("electron storage", () => {
+    it("interacts with electron-store", async () => {
+      setElectronStorage("authToken", "token-123");
+      getElectronStorage("authToken");
+      hasElectronStorage("authToken");
+      deleteFromElectronStorage("authToken");
+      clearElectronStorage();
+
+      const { getLastElectronStoreInstance } = await import("electron-store");
+      const instance = getLastElectronStoreInstance();
+
+      expect(instance?.set).toHaveBeenCalledWith("authToken", "token-123");
+      expect(instance?.get).toHaveBeenCalledWith("authToken");
+      expect(instance?.has).toHaveBeenCalledWith("authToken");
+      expect(instance?.delete).toHaveBeenCalledWith("authToken");
+      expect(instance?.clear).toHaveBeenCalled();
+    });
+  });
+});

src/main/@shared/utils.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+
+import { isDev, isPlatform } from "./utils.js";
+
+describe("@shared/utils", () => {
+  describe("isDev", () => {
+    it("returns true when NODE_ENV is development", () => {
+      process.env.NODE_ENV = "development";
+      expect(isDev()).toBe(true);
+    });
+
+    it("returns false when NODE_ENV is not development", () => {
+      process.env.NODE_ENV = "production";
+      expect(isDev()).toBe(false);
+    });
+  });
+
+  describe("isPlatform", () => {
+    it("returns true for current platform", () => {
+      expect(isPlatform(process.platform)).toBe(true);
+    });
+
+    it("returns false for different platform", () => {
+      const otherPlatform = process.platform === "win32" ? "darwin" : "win32";
+      expect(isPlatform(otherPlatform)).toBe(false);
+    });
+  });
+});

src/main/app-preload/ipc.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@devisfuture/electron-modular", () => ({
+  IpcHandler: () => () => undefined,
+}));
+
+describe("AppPreloadIpc", () => {
+  it("creates preload window on init", async () => {
+    const { AppPreloadIpc } = await import("./ipc.js");
+
+    const create = vi.fn();
+    const getWindow = vi.fn().mockReturnValue({ create });
+
+    const ipc = new AppPreloadIpc();
+    ipc.onInit({ getWindow } as any);
+
+    expect(getWindow).toHaveBeenCalledWith("window:preload-app");
+    expect(create).toHaveBeenCalled();
+  });
+});

src/main/app-preload/module.test.ts

@@ -0,0 +1,16 @@
+import "reflect-metadata";
+import { describe, expect, it } from "vitest";
+
+import { AppPreloadIpc } from "./ipc.js";
+import { AppPreloadModule } from "./module.js";
+import { AppPreloadWindow } from "./window.js";
+
+describe("AppPreloadModule", () => {
+  it("registers module metadata", () => {
+    const metadata = Reflect.getMetadata("RgModule", AppPreloadModule);
+
+    expect(metadata).toBeDefined();
+    expect(metadata.ipc).toEqual([AppPreloadIpc]);
+    expect(metadata.windows).toEqual([AppPreloadWindow]);
+  });
+});