test: unit & integration testing improvements (#213)

* test(electron): test improvements

- Modified assertions in `bridge.spec.ts` to expect `client.close()` to resolve to `undefined` instead of not throwing an error.
- Updated error messages in `getDebuggerEndpoint` tests in `bridge.spec.ts` to be more specific.
- Changed `describe` blocks in various test files from async to synchronous for consistency.
- Removed outdated test files and added new tests for mock operations to enhance coverage and maintainability.

* test(electron): enhance test coverage and error handling

- Added new tests in `launcher.spec.ts` to verify behavior when only `appEntryPoint` is provided and to handle unexpected errors from `getBinaryPath`.
- Introduced tests in `pathResolver.spec.ts` for `getElectronBinaryPath`, covering successful resolution, package.json not found, and binary path resolution failures.
- Improved mock implementations in `mock.spec.ts` and `triggerDeeplink.spec.ts` to ensure accurate behavior and error handling during tests.
- Updated assertions and added caching logic for userDataDir detection in `triggerDeeplink.spec.ts` to enhance reliability.

* fix: update command execution for cross-platform compatibility

- Modified the command execution in `build-package.ts` to use `cmd.exe` on Windows and `pnpm` on other platforms, ensuring proper invocation of the build process.
- Adjusted arguments for the spawn function to accommodate the changes in command structure, enhancing compatibility across different operating systems.

* fix(electron): resolve TypeScript errors in test suite

Fix pre-existing TS errors: vitest module augmentation shadowing, wrong
import source for waitUntilWindowAvailable, missing Result type narrowing
guards, and mismatched Assertion type parameters.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* test(electron): add coverage tests for mockAll, isMockFunction, mock, and pathResolver

Add tests for execute params/callback in mockAll, class mock path in
mock command, and getElectronBinaryPath resolution in pathResolver.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* test: update mock function types for better TypeScript compatibility

Refine the type definitions for mocked functions in the mockOperations test suite to allow for both function return types and string return types, enhancing type safety and clarity in the tests.

* chore: remove redundant mock definitions

Removed redundant mock definitions for appBuildInfo, binaryPath, and electronVersion, simplifying the test setup in pathResolver.spec.ts. This change enhances clarity and maintainability of the test suite.

* test(electron): extract MockApiMethod type for mock operation test stubs

Replace inline Record union type with a named MockApiMethod type that
explicitly declares getMockName, making the required property visible
at the type level.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* test(native-spy): enhance mock function tests with new scenarios

Added multiple test cases to improve coverage for mock functions, including scenarios for `mockResolvedValueOnce`, `mockRejectedValueOnce`, `mockRestore`, and context tracking. These additions ensure better validation of mock behavior and state management in various use cases.

* test(native-utils): add URL support for cwd in readPackageUp and readPackageUpSync

Enhanced tests for `readPackageUp` and `readPackageUpSync` to validate functionality when a URL is provided as the `cwd`. This includes checks for both asynchronous and synchronous methods, ensuring that the package JSON is correctly read from the specified URL. Additionally, improved error handling tests in `selectExecutable` to cover scenarios with empty paths and errors without message properties.

* test(electron): update mock cleanup method in tests

Replaced `vi.resetAllMocks()` with `vi.clearAllMocks()` in the mock operations test suite to ensure a more precise reset of mock states after each test, improving test isolation and reliability.

* test(native-spy): standardise test descriptions for mock function behavior

Updated test descriptions in `spy.spec.ts` to follow a consistent format, enhancing clarity and readability. Each test now begins with "should" to clearly define the expected behavior of the mock functions.

* test(native-spy): add new test cases for error handling and instance tracking

Introduced additional test scenarios in `spy.spec.ts` to enhance coverage for mock functions. New tests include tracking results for queued implementations that throw errors and verifying the tracking of instances, ensuring comprehensive validation of mock behavior.

---------

Co-authored-by: Claude Opus 4.6 <[email protected]>

Author: goosewobbler

@types/vitest/index.d.ts

@@ -1,9 +1,10 @@
+import 'vitest';
+
 interface CustomMatchers<R = unknown> {
   anyMockFunction(): R;
 }
+
 declare module 'vitest' {
-  interface Assertion<T = unknown> extends CustomMatchers<T> {}
+  interface Assertion<T> extends CustomMatchers<T> {}
   interface AsymmetricMatchersContaining extends CustomMatchers {}
 }
-
-export * from 'vitest';

packages/electron-cdp-bridge/test/bridge.spec.ts

@@ -284,14 +284,14 @@ describe('CdpBridge', () => {
       await client.connect();
       const result = client.close();
       triggerWebSocketEvent('close'); // emulate close event
-      await expect(result).resolves.not.toThrowError();
+      await expect(result).resolves.toBeUndefined();
     });
 
     it('should handle calling close before connect without errors', async () => {
       debuggerList = [{ webSocketDebuggerUrl: 'ws://localhost:123/uuid' }];
       const client = new CdpBridge();
       const result = client.close();
-      await expect(result).resolves.not.toThrowError();
+      await expect(result).resolves.toBeUndefined();
     });
   });
 
@@ -313,7 +313,7 @@ describe('CdpBridge', () => {
       debuggerList = [{ webSocketDebuggerUrl: 'ws://localhost:123/uuid' }];
       const client = new CdpBridge();
       const result = client.close();
-      await expect(result).resolves.not.toThrowError();
+      await expect(result).resolves.toBeUndefined();
     });
   });
 });

packages/electron-service/test/binaryPath.spec.ts

@@ -159,6 +159,7 @@ function testBinaryPath(options: TestBinaryPathOptions) {
 
     // Verify the result is successful
     expect(result.ok).toBe(true);
+    if (!result.ok) return;
     expect(result.value.binaryPath).toBeDefined();
 
     // Normalize path separators for cross-platform compatibility
@@ -195,7 +196,9 @@ describe('getBinaryPath', () => {
     const result = await getBinaryPath(pkgJSONPath, generateAppBuildInfo(false, true), '29.3.1', currentProcess);
 
     expect(result.ok).toBe(false);
+    if (result.ok) return;
     expect(result.error.pathGeneration.ok).toBe(false);
+    if (result.error.pathGeneration.ok) return;
     expect(result.error.pathGeneration.error?.errors).toContainEqual({
       type: 'UNSUPPORTED_PLATFORM',
       message: 'Unsupported platform: not-supported',
@@ -209,7 +212,9 @@ describe('getBinaryPath', () => {
     const result = await getBinaryPath(pkgJSONPath, generateAppBuildInfo(false, false), '29.3.1', currentProcess);
 
     expect(result.ok).toBe(false);
+    if (result.ok) return;
     expect(result.error.pathGeneration.ok).toBe(false);
+    if (result.error.pathGeneration.ok) return;
     expect(result.error.pathGeneration.error?.errors).toContainEqual({
       type: 'NO_BUILD_TOOL',
       message: 'Configurations that are neither Forge nor Builder are not supported.',

packages/electron-service/test/bridge.spec.ts

@@ -27,7 +27,7 @@ describe('getDebuggerEndpoint', () => {
           args: ['foo=bar'],
         },
       }),
-    ).toThrowError();
+    ).toThrowError(/--inspect/);
   });
 
   it('should throw the error when invalid host is set', () => {
@@ -39,7 +39,7 @@ describe('getDebuggerEndpoint', () => {
           args: ['foo=bar', `--inspect=${host}:${port}`],
         },
       }),
-    ).toThrowError();
+    ).toThrowError(/host|port|invalid/i);
   });
 
   it('should throw the error when invalid port number is set', () => {
@@ -51,7 +51,7 @@ describe('getDebuggerEndpoint', () => {
           args: ['foo=bar', `--inspect=${host}:${port}`],
         },
       }),
-    ).toThrowError();
+    ).toThrowError(/port|invalid|NaN/i);
   });
 });
 
@@ -70,7 +70,7 @@ describe('ElectronCdpBridge', () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
-  describe('connect', async () => {
+  describe('connect', () => {
     const expectedContextId = 999;
     const getMockedInstance = async () => {
       const cdpBridge = new ElectronCdpBridge();

packages/electron-service/test/commands/clearAllMocks.spec.ts

@@ -82,7 +82,7 @@ describe('execute Command', () => {
   });
 
   it('should execute a function when multi remote browser', async () => {
-    const mockElectron = globalThis.mrBrowser.getInstance();
+    const mockElectron = globalThis.mrBrowser.getInstance('browserA');
     await execute(globalThis.mrBrowser, client, (_electron, a, b, c) => a + b + c, 1, 2, 3);
 
     expect(mockElectron.electron.execute).toHaveBeenCalledTimes(2); // Because mrBrowser has 2 browser instance

packages/electron-service/test/commands/executeCdp.spec.ts

@@ -1,4 +1,3 @@
-/// <reference types="../../@types/vitest" />
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { isMockFunction } from '../../src/commands/isMockFunction.js';
 import { createMock } from '../../src/mock.js';

packages/electron-service/test/commands/isMockFunction.spec.ts

@@ -1,10 +1,11 @@
 import { afterEach, beforeEach, describe, expect, it, type Mock, vi } from 'vitest';
 
-import { createMock } from '../../src/mock.js';
+import { createClassMock, createMock } from '../../src/mock.js';
 import mockStore from '../../src/mockStore.js';
 
 vi.mock('../../src/mock.js', () => ({
   createMock: vi.fn(),
+  createClassMock: vi.fn(),
 }));
 vi.mock('../../src/mockStore.js', () => ({
   default: {
@@ -69,4 +70,27 @@ describe('mock Command', () => {
       expect(mockStore.setMock).toBeCalledWith(mockedGetName);
     });
   });
+
+  describe('class mock path (no funcName)', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should call createClassMock when no funcName is provided', async () => {
+      const mockClassInstance = { getMockName: () => 'electron.Tray', __constructor: vi.fn() };
+      (createClassMock as Mock).mockResolvedValue(mockClassInstance);
+
+      const result = await mock('Tray');
+      expect(createClassMock).toHaveBeenCalledWith('Tray', undefined);
+      expect(result).toBe(mockClassInstance);
+    });
+
+    it('should not interact with mockStore for class mocks', async () => {
+      (createClassMock as Mock).mockResolvedValue({ getMockName: () => 'electron.Tray' });
+
+      await mock('Tray');
+      expect(mockStore.getMock).not.toHaveBeenCalled();
+      expect(mockStore.setMock).not.toHaveBeenCalled();
+    });
+  });
 });

packages/electron-service/test/commands/mock.spec.ts

@@ -1,8 +1,10 @@
-/// <reference types="../../@types/vitest" />
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { mockAll } from '../../src/commands/mockAll.js';
 
+// Bind to a minimal context to satisfy the `this: ElectronServiceContext` parameter
+const callMockAll = mockAll.bind({});
+
 describe('mockAll Command', () => {
   beforeEach(async () => {
     globalThis.browser = {
@@ -21,7 +23,7 @@ describe('mockAll Command', () => {
   });
 
   it('should return mock functions for all API methods', async () => {
-    const mockedDialog = await mockAll('dialog');
+    const mockedDialog = await callMockAll('dialog');
     expect(mockedDialog).toStrictEqual({
       showOpenDialogSync: expect.anyMockFunction(),
       showOpenDialog: expect.anyMockFunction(),
@@ -36,4 +38,21 @@ describe('mockAll Command', () => {
     expect(mockedDialog.showOpenDialog).toHaveProperty('mock');
     expect(mockedDialog.showOpenDialog).toHaveProperty('mockImplementation');
   });
+
+  it('should call execute with the api name and internal flag', async () => {
+    await callMockAll('dialog');
+    expect(globalThis.browser.electron.execute).toHaveBeenCalledWith(expect.any(Function), 'dialog', {
+      internal: true,
+    });
+  });
+
+  it('should call the execute callback to extract keys from electron api', async () => {
+    await callMockAll('dialog');
+    const executeCallback = vi.mocked(globalThis.browser.electron.execute).mock.calls[0][0] as unknown as (
+      electron: Record<string, Record<string, unknown>>,
+      apiName: string,
+    ) => string;
+    const fakeElectron = { dialog: { foo: 1, bar: 2 } };
+    expect(executeCallback(fakeElectron, 'dialog')).toBe('foo,bar');
+  });
 });

packages/electron-service/test/commands/mockAll.spec.ts

@@ -0,0 +1,54 @@
+import { afterEach, beforeEach, describe, expect, it, type Mock, vi } from 'vitest';
+
+import { clearAllMocks } from '../../src/commands/clearAllMocks.js';
+import { resetAllMocks } from '../../src/commands/resetAllMocks.js';
+import { restoreAllMocks } from '../../src/commands/restoreAllMocks.js';
+import mockStore from '../../src/mockStore.js';
+
+vi.mock('../../src/mockStore.js', () => ({
+  default: {
+    getMocks: vi.fn(),
+  },
+}));
+
+type MockApiMethod = { getMockName: () => string; [key: string]: ReturnType<typeof vi.fn> | (() => string) };
+
+describe.each([
+  { name: 'clearAllMocks', fn: clearAllMocks, mockMethod: 'mockClear' },
+  { name: 'resetAllMocks', fn: resetAllMocks, mockMethod: 'mockReset' },
+  { name: 'restoreAllMocks', fn: restoreAllMocks, mockMethod: 'mockRestore' },
+] as const)('$name Command', ({ fn, mockMethod }) => {
+  let mockedGetName: MockApiMethod;
+  let mockedShowOpenDialog: MockApiMethod;
+
+  beforeEach(() => {
+    mockedGetName = {
+      getMockName: () => 'electron.app.getName',
+      [mockMethod]: vi.fn(),
+    };
+    mockedShowOpenDialog = {
+      getMockName: () => 'electron.dialog.showOpenDialog',
+      [mockMethod]: vi.fn(),
+    };
+    (mockStore.getMocks as Mock).mockReturnValue([
+      ['electron.app.getName', mockedGetName],
+      ['electron.dialog.showOpenDialog', mockedShowOpenDialog],
+    ]);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should operate on all mock functions when no apiName is specified', async () => {
+    await fn();
+    expect(mockedGetName[mockMethod]).toHaveBeenCalled();
+    expect(mockedShowOpenDialog[mockMethod]).toHaveBeenCalled();
+  });
+
+  it('should operate only on mock functions for a specific API', async () => {
+    await fn('app');
+    expect(mockedGetName[mockMethod]).toHaveBeenCalled();
+    expect(mockedShowOpenDialog[mockMethod]).not.toHaveBeenCalled();
+  });
+});