test(unit): create unit testing for all repo

Author: yuri-schwab

lib/powershell/common.ts

@@ -95,7 +95,7 @@ export class PSControlType extends PSObject {
 export class PSPoint extends PSObject {
     constructor(value: Position) {
         const requiredFields = ['x', 'y'];
-        if (!(Object.keys(value).every(requiredFields.includes) && typeof value.x === 'number' && typeof value.y === 'number')) {
+        if (!(requiredFields.every((f) => f in value) && typeof value.x === 'number' && typeof value.y === 'number')) {
             throw new errors.InvalidArgumentError('PSPoint accepts a Position object { x: number, y: number } in the constructor.');
         }
 
@@ -106,7 +106,7 @@ export class PSPoint extends PSObject {
 export class PSRect extends PSObject {
     constructor(value: Rect) {
         const requiredFields = ['x', 'y', 'width', 'height'];
-        if (!(Object.keys(value).every(requiredFields.includes) && typeof value.x === 'number' && typeof value.y === 'number' && typeof value.width === 'number' && typeof value.height === 'number')) {
+        if (!(requiredFields.every((f) => f in value) && typeof value.x === 'number' && typeof value.y === 'number' && typeof value.width === 'number' && typeof value.height === 'number')) {
             throw new errors.InvalidArgumentError('PSRect accepts a Rect object { x: number, y: number, width: number, height: number } in the constructor.');
         }
 
@@ -128,7 +128,7 @@ export class PSCultureInfo extends PSObject {
     constructor(name: string, useUserOverride?: boolean)
     constructor(culture: number, useUserOverride?: boolean)
     constructor(nameOrCulture: string | number, useUserOverride?: boolean) {
-        if (typeof nameOrCulture !== 'string' || (typeof nameOrCulture === 'number' && nameOrCulture < 0)) {
+        if (typeof nameOrCulture !== 'string' && (typeof nameOrCulture !== 'number' || nameOrCulture < 0)) {
             throw new errors.InvalidArgumentError('PSCultureInfo accepts a string or positive integer value in the constructor.');
         }
 

test/commands/app/app.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Unit tests for additional lib/commands/app.ts functions
+ * (getPageSource, getWindowHandle, getWindowHandles, getWindowRect, setWindow)
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+    getPageSource,
+    getWindowHandle,
+    getWindowHandles,
+    getWindowRect,
+    setWindow,
+} from '../../../lib/commands/app';
+import { createMockDriver } from '../../fixtures/driver';
+
+vi.mock('../../../lib/winapi/user32', () => ({
+    getWindowAllHandlesForProcessIds: vi.fn().mockReturnValue([]),
+    trySetForegroundWindow: vi.fn().mockReturnValue(true),
+}));
+
+describe('getPageSource', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('returns XML page source string', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('<Root><Child /></Root>');
+        const result = await getPageSource.call(driver);
+        expect(result).toBe('<Root><Child /></Root>');
+        expect(driver.sendPowerShellCommand).toHaveBeenCalledTimes(1);
+    });
+});
+
+describe('getWindowHandle', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('returns hex-formatted window handle', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('12648430'); // 0x00C0FFEE
+        const result = await getWindowHandle.call(driver);
+        expect(result).toBe('0x00c0ffee');
+    });
+
+    it('pads handle to 8 hex digits', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('1'); // 0x00000001
+        const result = await getWindowHandle.call(driver);
+        expect(result).toBe('0x00000001');
+    });
+});
+
+describe('getWindowHandles', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('returns array of hex window handles for each child window', async () => {
+        const driver = createMockDriver() as any;
+        // First call: findAll children of rootElement → two element IDs
+        // Subsequent calls: getNativeWindowHandle for each child
+        driver.sendPowerShellCommand
+            .mockResolvedValueOnce('1.1.1\n2.2.2') // findAll
+            .mockResolvedValueOnce('100') // handle for element 1
+            .mockResolvedValueOnce('200'); // handle for element 2
+
+        const result = await getWindowHandles.call(driver);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toBe('0x00000064'); // 100 = 0x64
+        expect(result[1]).toBe('0x000000c8'); // 200 = 0xC8
+    });
+
+    it('returns empty array when no child windows found', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue(''); // no elements
+        const result = await getWindowHandles.call(driver);
+        expect(result).toEqual([]);
+    });
+});
+
+describe('getWindowRect', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('returns parsed rect object', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('{"x":10,"y":20,"width":800,"height":600}');
+        const result = await getWindowRect.call(driver);
+        expect(result).toEqual({ x: 10, y: 20, width: 800, height: 600 });
+    });
+
+    it('replaces Infinity with max int32', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('{"x":Infinity,"y":0,"width":Infinity,"height":0}');
+        const result = await getWindowRect.call(driver);
+        expect(result.x).toBe(0x7FFFFFFF);
+        expect(result.width).toBe(0x7FFFFFFF);
+    });
+});
+
+describe('setWindow', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('sets root element by numeric handle', async () => {
+        const driver = createMockDriver() as any;
+        const { trySetForegroundWindow } = await import('../../../lib/winapi/user32');
+
+        // findFirst returns a valid element ID
+        driver.sendPowerShellCommand.mockResolvedValue('1.2.3');
+        await setWindow.call(driver, '12345');
+        expect(driver.sendPowerShellCommand).toHaveBeenCalled();
+        // The last PS command should set $rootElement
+        const calls = driver.sendPowerShellCommand.mock.calls;
+        const setRootCall = calls.find((c: any[]) => c[0].includes('$rootElement ='));
+        expect(setRootCall).toBeDefined();
+        expect(trySetForegroundWindow).toHaveBeenCalledWith(12345);
+    });
+
+    it('sets root element by window name', async () => {
+        const driver = createMockDriver() as any;
+
+        driver.sendPowerShellCommand
+            .mockResolvedValueOnce('') // numeric handle search fails (NaN)
+            .mockResolvedValueOnce('5.6.7'); // name search succeeds
+
+        await setWindow.call(driver, 'Calculator');
+        const calls = driver.sendPowerShellCommand.mock.calls;
+        const setRootCall = calls.find((c: any[]) => c[0].includes('$rootElement ='));
+        expect(setRootCall).toBeDefined();
+    });
+
+    it('throws NoSuchWindowError when window is not found after retries', async () => {
+        const driver = createMockDriver() as any;
+        // All calls return empty (window not found)
+        driver.sendPowerShellCommand.mockResolvedValue('');
+
+        await expect(setWindow.call(driver, 'NonExistentWindow')).rejects.toThrow('No window was found');
+    }, 10000);
+});

test/commands/device.test.ts

@@ -0,0 +1,45 @@
+/**
+ * Unit tests for lib/commands/device.ts
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getDeviceTime } from '../../lib/commands/device';
+import { createMockDriver } from '../fixtures/driver';
+
+/** Decode base64 Invoke-Expression wrappers to reveal the underlying PS command. */
+function decodeCommand(cmd: string): string {
+    const match = cmd.match(/FromBase64String\('([^']+)'\)/);
+    if (!match) {return cmd;}
+    return decodeCommand(Buffer.from(match[1], 'base64').toString('utf8'));
+}
+
+describe('getDeviceTime', () => {
+    beforeEach(() => vi.clearAllMocks());
+
+    it('returns formatted date string from PS command', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('2026-02-25T10:30:00+00:00');
+        const result = await getDeviceTime.call(driver);
+        expect(result).toBe('2026-02-25T10:30:00+00:00');
+        expect(driver.sendPowerShellCommand).toHaveBeenCalledTimes(1);
+    });
+
+    it('uses ISO 8061 format by default when no format provided', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('2026-02-25T10:30:00+00:00');
+        await getDeviceTime.call(driver);
+        const cmd = decodeCommand(driver.sendPowerShellCommand.mock.calls[0][0]);
+        expect(cmd).toContain('Get-Date');
+        expect(cmd).toContain('yyyy-MM-ddTHH:mm:sszzz');
+    });
+
+    it('uses custom format when provided', async () => {
+        const driver = createMockDriver() as any;
+        driver.sendPowerShellCommand.mockResolvedValue('25/02/2026');
+        const result = await getDeviceTime.call(driver, 'dd/MM/yyyy');
+        expect(result).toBe('25/02/2026');
+        const cmd = decodeCommand(driver.sendPowerShellCommand.mock.calls[0][0]);
+        expect(cmd).toContain('Get-Date');
+        // The custom format is embedded as a PSString (unicode-escaped)
+        expect(cmd).toContain('ToString');
+    });
+});