mirror of
https://github.com/eigent-ai/eigent.git
synced 2026-05-02 13:40:15 +00:00
1329 lines
40 KiB
TypeScript
1329 lines
40 KiB
TypeScript
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
|
|
|
|
// Mock all modules first
|
|
const mockApp = {
|
|
getPath: vi.fn(),
|
|
getVersion: vi.fn(),
|
|
getLocale: vi.fn(),
|
|
requestSingleInstanceLock: vi.fn(),
|
|
quit: vi.fn(),
|
|
setAsDefaultProtocolClient: vi.fn(),
|
|
isDefaultProtocolClient: vi.fn(),
|
|
setAppUserModelId: vi.fn(),
|
|
disableHardwareAcceleration: vi.fn(),
|
|
commandLine: {
|
|
appendSwitch: vi.fn(),
|
|
},
|
|
whenReady: vi.fn(),
|
|
on: vi.fn(),
|
|
};
|
|
|
|
const mockBrowserWindow = vi.fn(() => ({
|
|
loadURL: vi.fn(),
|
|
loadFile: vi.fn(),
|
|
show: vi.fn(),
|
|
close: vi.fn(),
|
|
minimize: vi.fn(),
|
|
isMaximized: vi.fn(),
|
|
maximize: vi.fn(),
|
|
unmaximize: vi.fn(),
|
|
isDestroyed: vi.fn(),
|
|
isFullScreen: vi.fn(),
|
|
webContents: {
|
|
openDevTools: vi.fn(),
|
|
send: vi.fn(),
|
|
on: vi.fn(),
|
|
setWindowOpenHandler: vi.fn(),
|
|
toggleDevTools: vi.fn(),
|
|
},
|
|
getAllWindows: vi.fn(),
|
|
}));
|
|
|
|
const mockDialog = {
|
|
showOpenDialog: vi.fn(),
|
|
showSaveDialog: vi.fn(),
|
|
};
|
|
|
|
const mockShell = {
|
|
openExternal: vi.fn(),
|
|
showItemInFolder: vi.fn(),
|
|
};
|
|
|
|
const mockIpcMain = {
|
|
handle: vi.fn(),
|
|
on: vi.fn(),
|
|
};
|
|
|
|
const mockMenu = {
|
|
setApplicationMenu: vi.fn(),
|
|
};
|
|
|
|
const mockFs = {
|
|
existsSync: vi.fn(),
|
|
readFileSync: vi.fn(),
|
|
writeFileSync: vi.fn(),
|
|
createReadStream: vi.fn(),
|
|
unlinkSync: vi.fn(),
|
|
createWriteStream: vi.fn(),
|
|
};
|
|
|
|
const mockFsp = {
|
|
access: vi.fn(),
|
|
stat: vi.fn(),
|
|
readFile: vi.fn(),
|
|
writeFile: vi.fn(),
|
|
rm: vi.fn(),
|
|
};
|
|
|
|
const mockOs = {
|
|
release: vi.fn(),
|
|
homedir: vi.fn(),
|
|
};
|
|
|
|
const mockLog = {
|
|
info: vi.fn(),
|
|
error: vi.fn(),
|
|
warn: vi.fn(),
|
|
transports: {
|
|
file: {
|
|
getFile: vi.fn(() => ({ path: "/mock/log/path" })),
|
|
},
|
|
console: { level: "info" },
|
|
},
|
|
};
|
|
|
|
const mockAxios = {
|
|
post: vi.fn(),
|
|
};
|
|
|
|
// Apply mocks
|
|
vi.mock("electron", () => ({
|
|
app: mockApp,
|
|
BrowserWindow: mockBrowserWindow,
|
|
ipcMain: mockIpcMain,
|
|
dialog: mockDialog,
|
|
shell: mockShell,
|
|
nativeTheme: { themeSource: "" },
|
|
protocol: { handle: vi.fn() },
|
|
session: { defaultSession: { on: vi.fn() } },
|
|
Menu: mockMenu,
|
|
}));
|
|
|
|
vi.mock("node:fs", () => ({
|
|
default: mockFs,
|
|
existsSync: mockFs.existsSync,
|
|
readFileSync: mockFs.readFileSync,
|
|
writeFileSync: mockFs.writeFileSync,
|
|
unlinkSync: mockFs.unlinkSync,
|
|
createReadStream: mockFs.createReadStream,
|
|
createWriteStream: mockFs.createWriteStream,
|
|
}));
|
|
|
|
vi.mock("fs/promises", () => mockFsp);
|
|
|
|
vi.mock("node:os", () => ({
|
|
default: mockOs,
|
|
homedir: mockOs.homedir,
|
|
release: mockOs.release,
|
|
}));
|
|
|
|
vi.mock("electron-log", () => ({ default: mockLog }));
|
|
|
|
vi.mock("axios", () => ({ default: mockAxios }));
|
|
|
|
vi.mock("form-data", () => ({
|
|
default: vi.fn(),
|
|
}));
|
|
|
|
// Mock internal modules (these can fail silently since we're testing logic, not actual imports)
|
|
vi.mock("../../../../electron/main/update", () => ({
|
|
update: vi.fn(),
|
|
registerUpdateIpcHandlers: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../../../../electron/main/init", () => ({
|
|
checkToolInstalled: vi.fn(),
|
|
installDependencies: vi.fn(),
|
|
killProcessOnPort: vi.fn(),
|
|
startBackend: vi.fn(),
|
|
findAvailablePort: vi.fn(),
|
|
}));
|
|
|
|
// Other internal mocks...
|
|
vi.mock("../../../../electron/main/webview", () => ({
|
|
WebViewManager: vi.fn(),
|
|
}));
|
|
vi.mock("../../../../electron/main/fileReader", () => ({
|
|
FileReader: vi.fn(),
|
|
}));
|
|
vi.mock("../../../../electron/main/utils/mcpConfig", () => ({
|
|
addMcp: vi.fn(),
|
|
removeMcp: vi.fn(),
|
|
updateMcp: vi.fn(),
|
|
readMcpConfig: vi.fn(),
|
|
}));
|
|
vi.mock("../../../../electron/main/utils/envUtil", () => ({
|
|
getEnvPath: vi.fn(),
|
|
updateEnvBlock: vi.fn(),
|
|
removeEnvKey: vi.fn(),
|
|
getEmailFolderPath: vi.fn(),
|
|
}));
|
|
vi.mock("../../../../electron/main/copy", () => ({ copyBrowserData: vi.fn() }));
|
|
vi.mock("../../../../electron/main/utils/log", () => ({ zipFolder: vi.fn() }));
|
|
vi.mock("tree-kill", () => ({ default: vi.fn() }));
|
|
|
|
// Import the mocked functions
|
|
import * as envUtil from "../../../../electron/main/utils/envUtil";
|
|
import * as mcpConfig from "../../../../electron/main/utils/mcpConfig";
|
|
import * as initModule from "../../../../electron/main/init";
|
|
|
|
// Cast the imports to mocked versions
|
|
const mockedEnvUtil = vi.mocked(envUtil);
|
|
const mockedMcpConfig = vi.mocked(mcpConfig);
|
|
const mockedInitModule = vi.mocked(initModule);
|
|
|
|
describe("Electron Main Index Functions", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
|
|
// Setup default mock returns
|
|
mockApp.getPath.mockReturnValue("/mock/user/data");
|
|
mockApp.getVersion.mockReturnValue("1.0.0");
|
|
mockApp.getLocale.mockReturnValue("en-US");
|
|
mockFs.existsSync.mockReturnValue(true);
|
|
mockFs.readFileSync.mockReturnValue("1.0.0");
|
|
mockOs.release.mockReturnValue("10.0.0");
|
|
mockOs.homedir.mockReturnValue("/home/user");
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
describe("checkAndInstallDepsOnUpdate", () => {
|
|
it("should return true when version file exists and matches current version", async () => {
|
|
mockFs.existsSync.mockReturnValue(true);
|
|
mockFs.readFileSync.mockReturnValue("1.0.0");
|
|
mockApp.getVersion.mockReturnValue("1.0.0");
|
|
|
|
// We test the logic that would be in the function
|
|
const versionExists = mockFs.existsSync("/mock/version.txt");
|
|
const savedVersion = mockFs.readFileSync("/mock/version.txt", "utf-8");
|
|
const currentVersion = mockApp.getVersion();
|
|
|
|
expect(versionExists).toBe(true);
|
|
expect(savedVersion).toBe(currentVersion);
|
|
});
|
|
|
|
it("should install dependencies when version file does not exist", async () => {
|
|
mockFs.existsSync.mockReturnValue(false);
|
|
mockApp.getVersion.mockReturnValue("1.0.0");
|
|
|
|
const versionExists = mockFs.existsSync("/mock/version.txt");
|
|
expect(versionExists).toBe(false);
|
|
});
|
|
|
|
it("should install dependencies when version has changed", async () => {
|
|
mockFs.existsSync.mockReturnValue(true);
|
|
mockFs.readFileSync.mockReturnValue("0.9.0");
|
|
mockApp.getVersion.mockReturnValue("1.0.0");
|
|
|
|
const savedVersion = mockFs.readFileSync("/mock/version.txt", "utf-8");
|
|
const currentVersion = mockApp.getVersion();
|
|
expect(savedVersion).not.toBe(currentVersion);
|
|
});
|
|
|
|
it("should handle errors during version check", async () => {
|
|
mockFs.existsSync.mockImplementation(() => {
|
|
throw new Error("File system error");
|
|
});
|
|
|
|
expect(() => mockFs.existsSync("/path")).toThrow("File system error");
|
|
});
|
|
});
|
|
|
|
describe("setupProtocolHandlers", () => {
|
|
it("should set up protocol handlers in development mode", () => {
|
|
process.env.NODE_ENV = "development";
|
|
mockApp.isDefaultProtocolClient.mockReturnValue(false);
|
|
|
|
// Test protocol handler setup logic
|
|
expect(mockApp.setAsDefaultProtocolClient).toBeDefined();
|
|
});
|
|
|
|
it("should set up protocol handlers in production mode", () => {
|
|
process.env.NODE_ENV = "production";
|
|
|
|
expect(mockApp.setAsDefaultProtocolClient).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("handleProtocolUrl", () => {
|
|
let mockWin: any;
|
|
|
|
beforeEach(() => {
|
|
mockWin = {
|
|
isDestroyed: vi.fn().mockReturnValue(false),
|
|
webContents: {
|
|
send: vi.fn(),
|
|
},
|
|
};
|
|
});
|
|
|
|
it("should handle OAuth protocol URLs correctly", () => {
|
|
// Since custom protocols might not work in test env, we test URL parsing directly
|
|
const urlStr = "https://example.com/oauth?provider=google&code=123456";
|
|
|
|
const urlObj = new URL(urlStr);
|
|
expect(urlObj.pathname).toBe("/oauth");
|
|
expect(urlObj.searchParams.get("provider")).toBe("google");
|
|
expect(urlObj.searchParams.get("code")).toBe("123456");
|
|
});
|
|
|
|
it("should handle authorization code URLs", () => {
|
|
const urlStr = "https://example.com/callback?code=abc123";
|
|
|
|
const urlObj = new URL(urlStr);
|
|
expect(urlObj.searchParams.get("code")).toBe("abc123");
|
|
});
|
|
|
|
it("should handle share token URLs", () => {
|
|
const urlStr = "https://example.com/share?share_token=token123";
|
|
|
|
const urlObj = new URL(urlStr);
|
|
expect(urlObj.searchParams.get("share_token")).toBe("token123");
|
|
});
|
|
|
|
it("should handle missing window gracefully", () => {
|
|
// Test error handling when window is not available
|
|
expect(mockLog.error).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("setupSingleInstanceLock", () => {
|
|
it("should quit app when single instance lock fails", () => {
|
|
mockApp.requestSingleInstanceLock.mockReturnValue(false);
|
|
|
|
const gotLock = mockApp.requestSingleInstanceLock();
|
|
expect(gotLock).toBe(false);
|
|
});
|
|
|
|
it("should set up event handlers when single instance lock succeeds", () => {
|
|
mockApp.requestSingleInstanceLock.mockReturnValue(true);
|
|
|
|
const gotLock = mockApp.requestSingleInstanceLock();
|
|
expect(gotLock).toBe(true);
|
|
expect(mockApp.on).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("getSystemLanguage", () => {
|
|
it("should return zh-cn for Chinese locale", async () => {
|
|
mockApp.getLocale.mockReturnValue("zh-CN");
|
|
|
|
const getSystemLanguage = async () => {
|
|
const locale = mockApp.getLocale();
|
|
return locale === "zh-CN" ? "zh-cn" : "en";
|
|
};
|
|
|
|
const result = await getSystemLanguage();
|
|
expect(result).toBe("zh-cn");
|
|
});
|
|
|
|
it("should return en for other locales", async () => {
|
|
mockApp.getLocale.mockReturnValue("en-US");
|
|
|
|
const getSystemLanguage = async () => {
|
|
const locale = mockApp.getLocale();
|
|
return locale === "zh-CN" ? "zh-cn" : "en";
|
|
};
|
|
|
|
const result = await getSystemLanguage();
|
|
expect(result).toBe("en");
|
|
});
|
|
});
|
|
|
|
describe("checkManagerInstance", () => {
|
|
it("should return manager when it exists", () => {
|
|
const mockManager = { test: "value" };
|
|
|
|
const checkManagerInstance = (manager: any, name: string) => {
|
|
if (!manager) {
|
|
throw new Error(`${name} not initialized`);
|
|
}
|
|
return manager;
|
|
};
|
|
|
|
const result = checkManagerInstance(mockManager, "TestManager");
|
|
expect(result).toBe(mockManager);
|
|
});
|
|
|
|
it("should throw error when manager is null or undefined", () => {
|
|
const checkManagerInstance = (manager: any, name: string) => {
|
|
if (!manager) {
|
|
throw new Error(`${name} not initialized`);
|
|
}
|
|
return manager;
|
|
};
|
|
|
|
expect(() => checkManagerInstance(null, "TestManager")).toThrow(
|
|
"TestManager not initialized"
|
|
);
|
|
expect(() => checkManagerInstance(undefined, "TestManager")).toThrow(
|
|
"TestManager not initialized"
|
|
);
|
|
});
|
|
});
|
|
|
|
describe("getBackupLogPath", () => {
|
|
it("should return correct backup log path", () => {
|
|
mockApp.getPath.mockReturnValue("/mock/userdata");
|
|
|
|
const getBackupLogPath = () => {
|
|
const userDataPath = mockApp.getPath("userData");
|
|
return `${userDataPath}/logs/main.log`;
|
|
};
|
|
|
|
const result = getBackupLogPath();
|
|
expect(result).toContain("logs");
|
|
expect(result).toContain("main.log");
|
|
});
|
|
});
|
|
|
|
describe("IPC Handlers", () => {
|
|
describe("get-browser-port handler", () => {
|
|
it("should return browser port", () => {
|
|
const mockHandler = vi.fn().mockReturnValue(9222);
|
|
|
|
expect(typeof mockHandler()).toBe("number");
|
|
});
|
|
});
|
|
|
|
describe("get-app-version handler", () => {
|
|
it("should return app version", () => {
|
|
mockApp.getVersion.mockReturnValue("1.0.0");
|
|
|
|
const result = mockApp.getVersion();
|
|
expect(result).toBe("1.0.0");
|
|
});
|
|
});
|
|
|
|
describe("get-backend-port handler", () => {
|
|
it("should return backend port", () => {
|
|
const mockHandler = vi.fn().mockReturnValue(5001);
|
|
|
|
expect(typeof mockHandler()).toBe("number");
|
|
});
|
|
});
|
|
|
|
describe("get-home-dir handler", () => {
|
|
it("should return USERPROFILE on Windows", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "win32" });
|
|
process.env.USERPROFILE = "C:\\Users\\TestUser";
|
|
|
|
const getHomeDir = () => {
|
|
const platform = process.platform;
|
|
return platform === "win32"
|
|
? process.env.USERPROFILE
|
|
: process.env.HOME;
|
|
};
|
|
|
|
const result = getHomeDir();
|
|
expect(result).toBe("C:\\Users\\TestUser");
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
|
|
it("should return HOME on non-Windows", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "darwin" });
|
|
process.env.HOME = "/home/testuser";
|
|
|
|
const getHomeDir = () => {
|
|
const platform = process.platform;
|
|
return platform === "win32"
|
|
? process.env.USERPROFILE
|
|
: process.env.HOME;
|
|
};
|
|
|
|
const result = getHomeDir();
|
|
expect(result).toBe("/home/testuser");
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
});
|
|
|
|
describe("select-file handler", () => {
|
|
it("should handle successful file selection", async () => {
|
|
const mockResult = {
|
|
canceled: false,
|
|
filePaths: ["/path/to/file.txt"],
|
|
};
|
|
mockDialog.showOpenDialog.mockResolvedValue(mockResult);
|
|
|
|
const result = await mockDialog.showOpenDialog({} as any, {
|
|
properties: ["openFile", "multiSelections"],
|
|
});
|
|
|
|
expect(result.canceled).toBe(false);
|
|
expect(result.filePaths).toHaveLength(1);
|
|
});
|
|
|
|
it("should handle cancelled file selection", async () => {
|
|
const mockResult = {
|
|
canceled: true,
|
|
filePaths: [],
|
|
};
|
|
mockDialog.showOpenDialog.mockResolvedValue(mockResult);
|
|
|
|
const result = await mockDialog.showOpenDialog({} as any, {
|
|
properties: ["openFile", "multiSelections"],
|
|
});
|
|
|
|
expect(result.canceled).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("read-file handler", () => {
|
|
it("should successfully read file", async () => {
|
|
const mockContent = "file content";
|
|
mockFsp.readFile.mockResolvedValue(mockContent);
|
|
|
|
const result = await mockFsp.readFile("/path/to/file.txt", "utf-8");
|
|
expect(result).toBe(mockContent);
|
|
});
|
|
|
|
it("should handle file read errors", async () => {
|
|
const error = new Error("File not found");
|
|
mockFsp.readFile.mockRejectedValue(error);
|
|
|
|
await expect(
|
|
mockFsp.readFile("/nonexistent/file.txt", "utf-8")
|
|
).rejects.toThrow("File not found");
|
|
});
|
|
});
|
|
|
|
describe("export-log handler", () => {
|
|
it("should successfully export log file", async () => {
|
|
mockFsp.access.mockResolvedValue(undefined);
|
|
mockFsp.stat.mockResolvedValue({ size: 1000 });
|
|
mockFsp.readFile.mockResolvedValue("log content");
|
|
mockDialog.showSaveDialog.mockResolvedValue({
|
|
canceled: false,
|
|
filePath: "/path/to/exported.log",
|
|
});
|
|
mockFsp.writeFile.mockResolvedValue(undefined);
|
|
|
|
// Test the export log logic
|
|
await expect(
|
|
mockFsp.writeFile("/path/to/exported.log", "log content", "utf-8")
|
|
).resolves.toBeUndefined();
|
|
});
|
|
|
|
it("should handle empty log file", async () => {
|
|
mockFsp.access.mockResolvedValue(undefined);
|
|
mockFsp.stat.mockResolvedValue({ size: 0 });
|
|
|
|
const stats = await mockFsp.stat("/mock/log/path");
|
|
expect(stats.size).toBe(0);
|
|
});
|
|
|
|
it("should handle cancelled save dialog", async () => {
|
|
mockDialog.showSaveDialog.mockResolvedValue({
|
|
canceled: true,
|
|
filePath: undefined,
|
|
});
|
|
|
|
const result = await mockDialog.showSaveDialog({
|
|
title: "save log file",
|
|
defaultPath: "test.log",
|
|
filters: [{ name: "log file", extensions: ["log", "txt"] }],
|
|
});
|
|
|
|
expect(result.canceled).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("upload-log handler", () => {
|
|
it("should successfully upload log file", async () => {
|
|
const mockResponse = { status: 200, data: { success: true } };
|
|
mockAxios.post.mockResolvedValue(mockResponse);
|
|
|
|
const result = await mockAxios.post("/api/test", {});
|
|
expect(result.status).toBe(200);
|
|
});
|
|
|
|
it("should handle upload errors", async () => {
|
|
const error = new Error("Network error");
|
|
mockAxios.post.mockRejectedValue(error);
|
|
|
|
await expect(mockAxios.post("/api/test", {})).rejects.toThrow(
|
|
"Network error"
|
|
);
|
|
});
|
|
|
|
it("should validate required parameters", () => {
|
|
const validateParams = (
|
|
email: string,
|
|
taskId: string,
|
|
baseUrl: string,
|
|
token: string
|
|
) => {
|
|
if (!email || !taskId || !baseUrl || !token) {
|
|
throw new Error("Missing required parameters");
|
|
}
|
|
return true;
|
|
};
|
|
|
|
expect(() => validateParams("", "task1", "url", "token")).toThrow(
|
|
"Missing required parameters"
|
|
);
|
|
expect(() => validateParams("email", "", "url", "token")).toThrow(
|
|
"Missing required parameters"
|
|
);
|
|
expect(() => validateParams("email", "task1", "", "token")).toThrow(
|
|
"Missing required parameters"
|
|
);
|
|
expect(() => validateParams("email", "task1", "url", "")).toThrow(
|
|
"Missing required parameters"
|
|
);
|
|
expect(validateParams("email", "task1", "url", "token")).toBe(true);
|
|
});
|
|
|
|
it("should sanitize task ID", () => {
|
|
const sanitizeTaskId = (taskId: string) => {
|
|
return taskId.replace(/[^a-zA-Z0-9_-]/g, "");
|
|
};
|
|
|
|
expect(sanitizeTaskId("task_123")).toBe("task_123");
|
|
expect(sanitizeTaskId("task-456")).toBe("task-456");
|
|
expect(sanitizeTaskId("task@#$%")).toBe("task");
|
|
expect(sanitizeTaskId("task 123")).toBe("task123");
|
|
});
|
|
});
|
|
|
|
describe("window control handlers", () => {
|
|
it("should handle window close", () => {
|
|
const mockWin = { close: vi.fn() };
|
|
|
|
mockWin.close();
|
|
expect(mockWin.close).toHaveBeenCalled();
|
|
});
|
|
|
|
it("should handle window minimize", () => {
|
|
const mockWin = { minimize: vi.fn() };
|
|
|
|
mockWin.minimize();
|
|
expect(mockWin.minimize).toHaveBeenCalled();
|
|
});
|
|
|
|
it("should handle window maximize toggle", () => {
|
|
const mockWin = {
|
|
isMaximized: vi.fn(),
|
|
maximize: vi.fn(),
|
|
unmaximize: vi.fn(),
|
|
};
|
|
|
|
mockWin.isMaximized.mockReturnValue(false);
|
|
if (!mockWin.isMaximized()) {
|
|
mockWin.maximize();
|
|
}
|
|
|
|
expect(mockWin.maximize).toHaveBeenCalled();
|
|
|
|
mockWin.isMaximized.mockReturnValue(true);
|
|
if (mockWin.isMaximized()) {
|
|
mockWin.unmaximize();
|
|
}
|
|
|
|
expect(mockWin.unmaximize).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("createWindow", () => {
|
|
it("should create window with correct configuration on macOS", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "darwin" });
|
|
|
|
const mockConfig = {
|
|
title: "Eigent",
|
|
width: 1200,
|
|
height: 800,
|
|
minWidth: 1200,
|
|
minHeight: 800,
|
|
frame: false,
|
|
transparent: true,
|
|
vibrancy: "sidebar",
|
|
visualEffectState: "active",
|
|
backgroundColor: "#00000000",
|
|
titleBarStyle: "hidden",
|
|
trafficLightPosition: { x: 10, y: 10 },
|
|
roundedCorners: true,
|
|
};
|
|
|
|
expect(mockConfig.titleBarStyle).toBe("hidden");
|
|
expect(mockConfig.trafficLightPosition).toEqual({ x: 10, y: 10 });
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
|
|
it("should create window with correct configuration on Windows", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "win32" });
|
|
|
|
const mockConfig = {
|
|
title: "Eigent",
|
|
width: 1200,
|
|
height: 800,
|
|
minWidth: 1200,
|
|
minHeight: 800,
|
|
frame: false,
|
|
transparent: true,
|
|
vibrancy: "sidebar",
|
|
visualEffectState: "active",
|
|
backgroundColor: "#00000000",
|
|
titleBarStyle: undefined,
|
|
trafficLightPosition: undefined,
|
|
roundedCorners: true,
|
|
};
|
|
|
|
expect(mockConfig.titleBarStyle).toBeUndefined();
|
|
expect(mockConfig.trafficLightPosition).toBeUndefined();
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
});
|
|
|
|
describe("setupWindowEventListeners", () => {
|
|
it("should set application menu to null", () => {
|
|
expect(mockMenu.setApplicationMenu).toBeDefined();
|
|
});
|
|
});
|
|
|
|
describe("setupDevToolsShortcuts", () => {
|
|
it("should handle F12 key for dev tools", () => {
|
|
const mockEvent = { preventDefault: vi.fn() };
|
|
const mockInput = { key: "F12", type: "keyDown" };
|
|
|
|
expect(mockInput.key).toBe("F12");
|
|
expect(mockInput.type).toBe("keyDown");
|
|
});
|
|
|
|
it("should handle Ctrl+Shift+I for dev tools", () => {
|
|
const mockInput = {
|
|
control: true,
|
|
shift: true,
|
|
key: "i",
|
|
type: "keyDown",
|
|
};
|
|
|
|
const shouldToggle =
|
|
mockInput.control &&
|
|
mockInput.shift &&
|
|
mockInput.key.toLowerCase() === "i" &&
|
|
mockInput.type === "keyDown";
|
|
|
|
expect(shouldToggle).toBe(true);
|
|
});
|
|
|
|
it("should handle Cmd+Shift+I for dev tools on Mac", () => {
|
|
const mockInput = {
|
|
meta: true,
|
|
shift: true,
|
|
key: "i",
|
|
type: "keyDown",
|
|
};
|
|
|
|
const shouldToggle =
|
|
mockInput.meta &&
|
|
mockInput.shift &&
|
|
mockInput.key.toLowerCase() === "i" &&
|
|
mockInput.type === "keyDown";
|
|
|
|
expect(shouldToggle).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("setupExternalLinkHandling", () => {
|
|
it("should open external links in default browser", () => {
|
|
const mockUrl = "https://example.com";
|
|
|
|
const shouldOpenExternal =
|
|
mockUrl.startsWith("https:") || mockUrl.startsWith("http:");
|
|
expect(shouldOpenExternal).toBe(true);
|
|
expect(mockShell.openExternal).toBeDefined();
|
|
});
|
|
|
|
it("should deny non-http(s) URLs", () => {
|
|
const mockUrl = "file:///etc/passwd";
|
|
|
|
const shouldOpenExternal =
|
|
mockUrl.startsWith("https:") || mockUrl.startsWith("http:");
|
|
expect(shouldOpenExternal).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("cleanupPythonProcess", () => {
|
|
it("should cleanup python process successfully", async () => {
|
|
const mockProcess = {
|
|
pid: 1234,
|
|
kill: vi.fn(),
|
|
};
|
|
|
|
// Test cleanup logic
|
|
if (mockProcess) {
|
|
mockProcess.kill();
|
|
}
|
|
|
|
expect(mockProcess.kill).toHaveBeenCalled();
|
|
});
|
|
|
|
it("should handle cleanup errors gracefully", async () => {
|
|
const mockKill = vi.fn().mockImplementation((pid, callback) => {
|
|
callback(new Error("Process not found"));
|
|
});
|
|
|
|
// Test error handling in cleanup
|
|
expect(() => {
|
|
mockKill(1234, (error: Error) => {
|
|
if (error) throw error;
|
|
});
|
|
}).toThrow("Process not found");
|
|
});
|
|
});
|
|
|
|
describe("handleDependencyInstallation", () => {
|
|
it("should install dependencies successfully", async () => {
|
|
const mockInstallDependencies = vi.fn().mockResolvedValue(true);
|
|
const mockCheckToolInstalled = vi.fn().mockResolvedValue(true);
|
|
const mockStartBackend = vi.fn().mockResolvedValue({ pid: 1234 });
|
|
|
|
const result = await mockInstallDependencies();
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
it("should handle installation failure", async () => {
|
|
const mockInstallDependencies = vi.fn().mockResolvedValue(false);
|
|
|
|
const result = await mockInstallDependencies();
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it("should start backend when tool is installed", async () => {
|
|
const mockCheckToolInstalled = vi.fn().mockResolvedValue(true);
|
|
const mockStartBackend = vi.fn().mockResolvedValue({ pid: 1234 });
|
|
|
|
const isToolInstalled = await mockCheckToolInstalled();
|
|
if (isToolInstalled) {
|
|
const process = await mockStartBackend(() => {});
|
|
expect(process).toEqual({ pid: 1234 });
|
|
}
|
|
});
|
|
|
|
it("should skip backend start when tool is not installed", async () => {
|
|
const mockCheckToolInstalled = vi.fn().mockResolvedValue(false);
|
|
|
|
const isToolInstalled = await mockCheckToolInstalled();
|
|
expect(isToolInstalled).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe("Browser Path Constants", () => {
|
|
it("should define correct Windows browser paths", () => {
|
|
const BROWSER_PATHS = {
|
|
win32: {
|
|
chrome: "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
|
|
edge: "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
|
|
firefox: "C:\\Program Files\\Mozilla Firefox\\firefox.exe",
|
|
},
|
|
};
|
|
|
|
expect(BROWSER_PATHS.win32.chrome).toContain("chrome.exe");
|
|
expect(BROWSER_PATHS.win32.edge).toContain("msedge.exe");
|
|
expect(BROWSER_PATHS.win32.firefox).toContain("firefox.exe");
|
|
});
|
|
|
|
it("should define correct macOS browser paths", () => {
|
|
const BROWSER_PATHS = {
|
|
darwin: {
|
|
chrome: "/Applications/Google Chrome.app",
|
|
edge: "/Applications/Microsoft Edge.app",
|
|
firefox: "/Applications/Firefox.app",
|
|
safari: "/Applications/Safari.app",
|
|
},
|
|
};
|
|
|
|
expect(BROWSER_PATHS.darwin.chrome).toContain(".app");
|
|
expect(BROWSER_PATHS.darwin.edge).toContain(".app");
|
|
expect(BROWSER_PATHS.darwin.firefox).toContain(".app");
|
|
expect(BROWSER_PATHS.darwin.safari).toContain(".app");
|
|
});
|
|
});
|
|
|
|
describe("App Event Handlers", () => {
|
|
it("should handle app ready event", () => {
|
|
expect(mockApp.whenReady).toBeDefined();
|
|
});
|
|
|
|
it("should handle window-all-closed event", () => {
|
|
const originalPlatform = process.platform;
|
|
|
|
// Test non-darwin platform
|
|
Object.defineProperty(process, "platform", { value: "win32" });
|
|
const shouldQuit = process.platform !== "darwin";
|
|
expect(shouldQuit).toBe(true);
|
|
|
|
// Test darwin platform
|
|
Object.defineProperty(process, "platform", { value: "darwin" });
|
|
const shouldNotQuit = process.platform !== "darwin";
|
|
expect(shouldNotQuit).toBe(false);
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
|
|
it("should handle app activate event", () => {
|
|
const mockWindows = [{ show: vi.fn() }];
|
|
|
|
if (mockWindows.length > 0) {
|
|
mockWindows[0].show();
|
|
expect(mockWindows[0].show).toHaveBeenCalled();
|
|
}
|
|
});
|
|
|
|
it("should handle before-quit event", () => {
|
|
const mockProcess = { pid: 1234 };
|
|
|
|
// Test cleanup logic
|
|
if (mockProcess) {
|
|
expect(mockProcess.pid).toBe(1234);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("Environment and Platform Detection", () => {
|
|
it("should detect Windows 7 and disable hardware acceleration", () => {
|
|
mockOs.release.mockReturnValue("6.1.7601");
|
|
|
|
const release = mockOs.release();
|
|
const isWindows7 = release.startsWith("6.1");
|
|
|
|
expect(isWindows7).toBe(true);
|
|
});
|
|
|
|
it("should not disable hardware acceleration on newer Windows", () => {
|
|
mockOs.release.mockReturnValue("10.0.19041");
|
|
|
|
const release = mockOs.release();
|
|
const isWindows7 = release.startsWith("6.1");
|
|
|
|
expect(isWindows7).toBe(false);
|
|
});
|
|
|
|
it("should set app user model ID on Windows", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "win32" });
|
|
|
|
const isWindows = process.platform === "win32";
|
|
expect(isWindows).toBe(true);
|
|
|
|
// Restore original platform
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
});
|
|
|
|
describe("Constants and Paths", () => {
|
|
it("should define correct path constants", () => {
|
|
const mockDirname = "/app/dist-electron/main";
|
|
const mockPath = {
|
|
join: (dir: string, ...paths: string[]) => {
|
|
const allPaths = [dir, ...paths];
|
|
return allPaths.join("/").replace(/\/+/g, "/");
|
|
},
|
|
};
|
|
|
|
const MAIN_DIST = mockPath.join(mockDirname, "../..");
|
|
const RENDERER_DIST = mockPath.join(MAIN_DIST, "dist");
|
|
|
|
expect(MAIN_DIST).toContain("dist-electron");
|
|
expect(RENDERER_DIST).toContain("dist");
|
|
});
|
|
|
|
it("should handle VITE_DEV_SERVER_URL correctly", () => {
|
|
const VITE_DEV_SERVER_URL = "http://localhost:3000";
|
|
const MAIN_DIST = "/app";
|
|
const mockPath = {
|
|
join: (dir: string, ...paths: string[]) => `${dir}/${paths.join("/")}`,
|
|
};
|
|
|
|
const VITE_PUBLIC = VITE_DEV_SERVER_URL
|
|
? mockPath.join(MAIN_DIST, "public")
|
|
: mockPath.join(MAIN_DIST, "dist");
|
|
|
|
expect(VITE_PUBLIC).toContain("public");
|
|
|
|
// Test when no dev server URL
|
|
const VITE_PUBLIC_PROD = !VITE_DEV_SERVER_URL
|
|
? mockPath.join(MAIN_DIST, "public")
|
|
: mockPath.join(MAIN_DIST, "dist");
|
|
|
|
expect(VITE_PUBLIC_PROD).toContain("dist");
|
|
});
|
|
});
|
|
|
|
describe("MCP Handlers", () => {
|
|
it("should handle mcp-install", () => {
|
|
const mockHandler = vi.fn((_event, name, mcp) => {
|
|
mockedMcpConfig.addMcp(name, mcp);
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("mcp-install", mockHandler);
|
|
|
|
mockHandler({}, "test-mcp", { data: "data" });
|
|
expect(mockedMcpConfig.addMcp).toHaveBeenCalledWith("test-mcp", {
|
|
data: "data",
|
|
});
|
|
});
|
|
|
|
it("should handle mcp-remove", () => {
|
|
const mockHandler = vi.fn((_event, name) => {
|
|
mockedMcpConfig.removeMcp(name);
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("mcp-remove", mockHandler);
|
|
|
|
mockHandler({}, "test-mcp");
|
|
expect(mockedMcpConfig.removeMcp).toHaveBeenCalledWith("test-mcp");
|
|
});
|
|
|
|
it("should handle mcp-update", () => {
|
|
const mockHandler = vi.fn((_event, name, mcp) => {
|
|
mockedMcpConfig.updateMcp(name, mcp);
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("mcp-update", mockHandler);
|
|
|
|
mockHandler({}, "test-mcp", { data: "new-data" });
|
|
expect(mockedMcpConfig.updateMcp).toHaveBeenCalledWith("test-mcp", {
|
|
data: "new-data",
|
|
});
|
|
});
|
|
|
|
it("should handle mcp-list", async () => {
|
|
const mockData = { mcp1: { version: "1.0" } };
|
|
mockedMcpConfig.readMcpConfig.mockResolvedValue(mockData);
|
|
const mockHandler = vi.fn(() => mockedMcpConfig.readMcpConfig());
|
|
mockIpcMain.handle("mcp-list", mockHandler);
|
|
|
|
const result = await mockHandler();
|
|
expect(mockedMcpConfig.readMcpConfig).toHaveBeenCalled();
|
|
expect(result).toEqual(mockData);
|
|
});
|
|
});
|
|
|
|
describe("Environment Variable Handlers", () => {
|
|
beforeEach(() => {
|
|
mockedEnvUtil.getEnvPath.mockReturnValue("/mock/env/path/.env");
|
|
});
|
|
|
|
it("should handle get-env-path", async () => {
|
|
const mockHandler = vi.fn((_event, email) =>
|
|
mockedEnvUtil.getEnvPath(email)
|
|
);
|
|
mockIpcMain.handle("get-env-path", mockHandler);
|
|
|
|
const result = await mockHandler({}, "test@example.com");
|
|
expect(mockedEnvUtil.getEnvPath).toHaveBeenCalledWith("test@example.com");
|
|
expect(result).toBe("/mock/env/path/.env");
|
|
});
|
|
|
|
it("should handle env-write", async () => {
|
|
const mockHandler = vi.fn(async (_event, email, { key, value }) => {
|
|
const ENV_PATH = mockedEnvUtil.getEnvPath(email);
|
|
mockFs.readFileSync.mockReturnValue("EXISTING_KEY=old_value");
|
|
let lines = mockFs.readFileSync(ENV_PATH, "utf-8").split(/\r?\n/);
|
|
|
|
// Mock updateEnvBlock to return an array
|
|
mockedEnvUtil.updateEnvBlock.mockReturnValue([
|
|
"EXISTING_KEY=old_value",
|
|
"NEW_KEY=new_value",
|
|
]);
|
|
lines = mockedEnvUtil.updateEnvBlock(lines, { [key]: value });
|
|
mockFs.writeFileSync(ENV_PATH, lines.join("\n"), "utf-8");
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("env-write", mockHandler);
|
|
|
|
await mockHandler({}, "test@example.com", {
|
|
key: "NEW_KEY",
|
|
value: "new_value",
|
|
});
|
|
expect(mockFs.writeFileSync).toHaveBeenCalled();
|
|
});
|
|
|
|
it("should handle env-remove", async () => {
|
|
const mockHandler = vi.fn(async (_event, email, key) => {
|
|
const ENV_PATH = mockedEnvUtil.getEnvPath(email);
|
|
mockFs.readFileSync.mockReturnValue(
|
|
"KEY_TO_REMOVE=some_value\nOTHER_KEY=other_value"
|
|
);
|
|
let lines = mockFs.readFileSync(ENV_PATH, "utf-8").split(/\r?\n/);
|
|
|
|
// Mock removeEnvKey to return an array
|
|
mockedEnvUtil.removeEnvKey.mockReturnValue(["OTHER_KEY=other_value"]);
|
|
lines = mockedEnvUtil.removeEnvKey(lines, key);
|
|
mockFs.writeFileSync(ENV_PATH, lines.join("\n"), "utf-8");
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("env-remove", mockHandler);
|
|
|
|
await mockHandler({}, "test@example.com", "KEY_TO_REMOVE");
|
|
expect(mockFs.writeFileSync).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("File and Folder Handlers", () => {
|
|
it("should handle reveal-in-folder", () => {
|
|
const mockHandler = vi.fn((_event, filePath) => {
|
|
mockShell.showItemInFolder(filePath);
|
|
});
|
|
mockIpcMain.handle("reveal-in-folder", mockHandler);
|
|
|
|
mockHandler({}, "/path/to/file");
|
|
expect(mockShell.showItemInFolder).toHaveBeenCalledWith("/path/to/file");
|
|
});
|
|
|
|
it("should handle delete-folder successfully", async () => {
|
|
mockedEnvUtil.getEmailFolderPath.mockReturnValue({
|
|
MCP_REMOTE_CONFIG_DIR: "/mock/mcp/dir",
|
|
MCP_CONFIG_DIR: "",
|
|
tempEmail: "",
|
|
hasToken: false,
|
|
});
|
|
mockFs.existsSync.mockReturnValue(true);
|
|
mockFsp.stat.mockResolvedValue({ isDirectory: () => true } as any);
|
|
mockFsp.rm.mockResolvedValue(undefined);
|
|
|
|
const mockHandler = vi.fn(async (_event, email) => {
|
|
const { MCP_REMOTE_CONFIG_DIR } =
|
|
mockedEnvUtil.getEmailFolderPath(email);
|
|
if (!mockFs.existsSync(MCP_REMOTE_CONFIG_DIR)) {
|
|
return { success: false, error: "Folder does not exist" };
|
|
}
|
|
const stats = await mockFsp.stat(MCP_REMOTE_CONFIG_DIR);
|
|
if (!stats.isDirectory()) {
|
|
return { success: false, error: "Path is not a directory" };
|
|
}
|
|
await mockFsp.rm(MCP_REMOTE_CONFIG_DIR, {
|
|
recursive: true,
|
|
force: true,
|
|
});
|
|
return { success: true };
|
|
});
|
|
mockIpcMain.handle("delete-folder", mockHandler);
|
|
|
|
const result = await mockHandler({}, "test@example.com");
|
|
expect(mockedEnvUtil.getEmailFolderPath).toHaveBeenCalledWith(
|
|
"test@example.com"
|
|
);
|
|
expect(mockFsp.rm).toHaveBeenCalledWith("/mock/mcp/dir", {
|
|
recursive: true,
|
|
force: true,
|
|
});
|
|
expect(result).toEqual({ success: true });
|
|
});
|
|
|
|
it("should handle delete-folder when folder does not exist", async () => {
|
|
mockedEnvUtil.getEmailFolderPath.mockReturnValue({
|
|
MCP_REMOTE_CONFIG_DIR: "/mock/mcp/dir",
|
|
MCP_CONFIG_DIR: "",
|
|
tempEmail: "",
|
|
hasToken: false,
|
|
});
|
|
mockFs.existsSync.mockReturnValue(false);
|
|
|
|
const mockHandler = vi.fn(async (_event, email) => {
|
|
const { MCP_REMOTE_CONFIG_DIR } =
|
|
mockedEnvUtil.getEmailFolderPath(email);
|
|
if (!mockFs.existsSync(MCP_REMOTE_CONFIG_DIR)) {
|
|
return { success: false, error: "Folder does not exist" };
|
|
}
|
|
//...
|
|
});
|
|
mockIpcMain.handle("delete-folder", mockHandler);
|
|
|
|
const result = await mockHandler({}, "test@example.com");
|
|
expect(result).toEqual({
|
|
success: false,
|
|
error: "Folder does not exist",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Backend and Dependency Handlers", () => {
|
|
it("should handle check-tool-installed", async () => {
|
|
mockedInitModule.checkToolInstalled.mockResolvedValue(true);
|
|
const mockHandler = vi.fn(async () => {
|
|
const isInstalled = await mockedInitModule.checkToolInstalled();
|
|
return { success: true, isInstalled };
|
|
});
|
|
mockIpcMain.handle("check-tool-installed", mockHandler);
|
|
|
|
const result = await mockHandler();
|
|
expect(mockedInitModule.checkToolInstalled).toHaveBeenCalled();
|
|
expect(result).toEqual({ success: true, isInstalled: true });
|
|
});
|
|
|
|
it("should handle installation triggering", async () => {
|
|
// Create a mock handler that actually calls installDependencies
|
|
const mockHandler = vi.fn(async () => {
|
|
const result = await mockedInitModule.installDependencies();
|
|
return result;
|
|
});
|
|
mockIpcMain.handle("install-dependencies", mockHandler);
|
|
mockIpcMain.handle("frontend-ready", mockHandler);
|
|
|
|
mockedInitModule.installDependencies.mockResolvedValue(true);
|
|
|
|
await mockHandler();
|
|
expect(mockedInitModule.installDependencies).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("FileReader and WebViewManager Handlers", () => {
|
|
let mockFileReader: any;
|
|
let mockWebViewManager: any;
|
|
|
|
beforeEach(() => {
|
|
mockFileReader = {
|
|
openFile: vi.fn(),
|
|
getFileList: vi.fn(),
|
|
};
|
|
mockWebViewManager = {
|
|
captureWebview: vi.fn(),
|
|
createWebview: vi.fn(),
|
|
hideWebview: vi.fn(),
|
|
showWebview: vi.fn(),
|
|
changeViewSize: vi.fn(),
|
|
hideAllWebview: vi.fn(),
|
|
getActiveWebview: vi.fn(),
|
|
setSize: vi.fn(),
|
|
getShowWebview: vi.fn(),
|
|
destroyWebview: vi.fn(),
|
|
};
|
|
|
|
// Mock the managers being available
|
|
vi.doMock("../../../../electron/main/fileReader", () => ({
|
|
FileReader: vi.fn(() => mockFileReader),
|
|
}));
|
|
vi.doMock("../../../../electron/main/webview", () => ({
|
|
WebViewManager: vi.fn(() => mockWebViewManager),
|
|
}));
|
|
});
|
|
|
|
it("should handle open-file", async () => {
|
|
const mockHandler = vi.fn((...args) => mockFileReader.openFile(...args));
|
|
mockIpcMain.handle("open-file", mockHandler);
|
|
await mockHandler("type", "path", true);
|
|
expect(mockFileReader.openFile).toHaveBeenCalledWith(
|
|
"type",
|
|
"path",
|
|
true
|
|
);
|
|
});
|
|
|
|
it("should handle get-file-list", async () => {
|
|
const mockHandler = vi.fn((...args) =>
|
|
mockFileReader.getFileList(...args)
|
|
);
|
|
mockIpcMain.handle("get-file-list", mockHandler);
|
|
await mockHandler("email", "taskId");
|
|
expect(mockFileReader.getFileList).toHaveBeenCalledWith(
|
|
"email",
|
|
"taskId"
|
|
);
|
|
});
|
|
|
|
it("should handle create-webview", async () => {
|
|
const mockHandler = vi.fn((...args) =>
|
|
mockWebViewManager.createWebview(...args)
|
|
);
|
|
mockIpcMain.handle("create-webview", mockHandler);
|
|
await mockHandler("id");
|
|
expect(mockWebViewManager.createWebview).toHaveBeenCalledWith("id");
|
|
});
|
|
|
|
it("should handle webview-destroy", async () => {
|
|
const mockHandler = vi.fn((...args) =>
|
|
mockWebViewManager.destroyWebview(...args)
|
|
);
|
|
mockIpcMain.handle("webview-destroy", mockHandler);
|
|
await mockHandler();
|
|
expect(mockWebViewManager.destroyWebview).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("Application Lifecycle", () => {
|
|
it("should quit on window-all-closed for non-darwin platforms", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "win32" });
|
|
|
|
mockApp.on.mockImplementation((event, listener) => {
|
|
if (event === "window-all-closed") {
|
|
listener();
|
|
}
|
|
});
|
|
|
|
// This is a simplified representation of the app.on('window-all-closed') logic
|
|
const windowAllClosedHandler = () => {
|
|
if (process.platform !== "darwin") {
|
|
mockApp.quit();
|
|
}
|
|
};
|
|
|
|
windowAllClosedHandler();
|
|
expect(mockApp.quit).toHaveBeenCalled();
|
|
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
|
|
it("should not quit on window-all-closed for darwin platforms", () => {
|
|
const originalPlatform = process.platform;
|
|
Object.defineProperty(process, "platform", { value: "darwin" });
|
|
vi.clearAllMocks(); // Clear mocks from previous test
|
|
|
|
const windowAllClosedHandler = () => {
|
|
if (process.platform !== "darwin") {
|
|
mockApp.quit();
|
|
}
|
|
};
|
|
|
|
windowAllClosedHandler();
|
|
expect(mockApp.quit).not.toHaveBeenCalled();
|
|
|
|
Object.defineProperty(process, "platform", { value: originalPlatform });
|
|
});
|
|
|
|
it("should call cleanup on before-quit", () => {
|
|
const mockCleanup = vi.fn();
|
|
mockApp.on.mockImplementation((event, listener) => {
|
|
if (event === "before-quit") {
|
|
listener();
|
|
}
|
|
});
|
|
|
|
const beforeQuitHandler = () => {
|
|
mockCleanup();
|
|
};
|
|
|
|
beforeQuitHandler();
|
|
expect(mockCleanup).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|