Add an ipc to reset the Tooloop Control Centre watchdog.

test/watchdog.test.js

@@ -0,0 +1,121 @@
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const test = require('node:test');
+const {
+    WATCHDOG_CHANNEL,
+    WATCHDOG_PATH,
+    isAuthorizedWatchdogEvent,
+    registerWatchdogHandler,
+    sendWatchdogReset
+} = require('../js/watchdog.js');
+
+function createHttpClient({ statusCode = 204, hang = false } = {}) {
+    const calls = [];
+    const httpClient = {
+        request(options, onResponse) {
+            const request = new EventEmitter();
+            request.destroy = (error) => request.emit('error', error);
+            request.end = (body) => {
+                calls.push({ options, body });
+                if (!hang) {
+                    queueMicrotask(() => onResponse({ statusCode, resume() {} }));
+                }
+            };
+            return request;
+        }
+    };
+    return { httpClient, calls };
+}
+
+test('sends healthy true as a fixed local POST', async () => {
+    const { httpClient, calls } = createHttpClient();
+
+    await sendWatchdogReset({ healthy: true }, httpClient);
+
+    assert.deepEqual(calls, [{
+        options: {
+            hostname: 'localhost',
+            path: WATCHDOG_PATH,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' }
+        },
+        body: '{"healthy":true}'
+    }]);
+});
+
+test('sends healthy false in the request body', async () => {
+    const { httpClient, calls } = createHttpClient();
+
+    await sendWatchdogReset({ healthy: false }, httpClient);
+
+    assert.equal(calls[0].body, '{"healthy":false}');
+});
+
+test('rejects malformed payloads without making a request', async () => {
+    const { httpClient, calls } = createHttpClient();
+
+    for (const payload of [null, [], {}, { healthy: 1 }, { healthy: true, url: 'http://example.test' }]) {
+        await assert.rejects(sendWatchdogReset(payload, httpClient), /boolean healthy field/);
+    }
+
+    assert.equal(calls.length, 0);
+});
+
+test('rejects non-success HTTP responses without parsing their body', async () => {
+    const { httpClient } = createHttpClient({ statusCode: 503 });
+
+    await assert.rejects(sendWatchdogReset({ healthy: true }, httpClient), /HTTP 503/);
+});
+
+test('rejects responses without a numeric HTTP status', async () => {
+    const { httpClient } = createHttpClient({ statusCode: null });
+
+    await assert.rejects(sendWatchdogReset({ healthy: true }, httpClient), /HTTP unknown/);
+});
+
+test('rejects requests that exceed the timeout', async () => {
+    const { httpClient } = createHttpClient({ hang: true });
+
+    await assert.rejects(sendWatchdogReset({ healthy: true }, httpClient, 5), /timed out after 5 ms/);
+});
+
+test('rejects unauthorized renderers without making a request', async () => {
+    let registeredChannel;
+    let handler;
+    const { httpClient, calls } = createHttpClient();
+    const mainFrame = { url: 'https://allowed.example/' };
+    const mainWindow = { isDestroyed: () => false, webContents: { mainFrame } };
+    const ipcMain = {
+        handle(channel, registeredHandler) {
+            registeredChannel = channel;
+            handler = registeredHandler;
+        }
+    };
+
+    registerWatchdogHandler(ipcMain, {
+        isAuthorized: (event) => isAuthorizedWatchdogEvent(event, mainWindow, (url) => url === mainFrame.url),
+        httpClient
+    });
+
+    assert.equal(registeredChannel, WATCHDOG_CHANNEL);
+    const otherRenderer = { sender: { mainFrame }, senderFrame: mainFrame };
+    await assert.rejects(handler(otherRenderer, { healthy: true }), /not authorized/);
+    assert.equal(calls.length, 0);
+});
+
+test('rejects subframes and renderers on disallowed URLs', () => {
+    const mainFrame = { url: 'https://allowed.example/' };
+    const mainWindow = { isDestroyed: () => false, webContents: { mainFrame } };
+    const isUrlAllowed = (url) => url === mainFrame.url;
+    const blockedFrame = { url: 'https://blocked.example/' };
+    const blockedWindow = { isDestroyed: () => false, webContents: { mainFrame: blockedFrame } };
+
+    assert.equal(isAuthorizedWatchdogEvent({
+        sender: mainWindow.webContents,
+        senderFrame: { url: mainFrame.url }
+    }, mainWindow, isUrlAllowed), false);
+    assert.equal(isAuthorizedWatchdogEvent({
+        sender: blockedWindow.webContents,
+        senderFrame: blockedFrame
+    }, blockedWindow, isUrlAllowed), false);
+});