[Init] Initial commit - NetMesh terminal manager

electron/plugins/browserPluginRuntime.test.cjs

@@ -0,0 +1,204 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { EventEmitter } = require("node:events");
+const test = require("node:test");
+
+const {
+  BrowserPluginRuntime,
+  normalizeConsoleLevel,
+  sanitizePluginSource,
+} = require("./browserPluginRuntime.cjs");
+
+class FakePort extends EventEmitter {
+  constructor() {
+    super();
+    this.sent = [];
+    this.transferLists = [];
+  }
+
+  postMessage(message, transfer = []) {
+    this.sent.push(message);
+    this.transferLists.push(transfer);
+    if (message.method === "plugin.initialize") {
+      queueMicrotask(() => this.emit("message", { data: {
+        jsonrpc: "2.0",
+        id: message.id,
+        result: {
+          pluginId: "com.example.browser-runtime",
+          pluginVersion: "1.0.0",
+          apiVersion: "0.1.0-internal",
+          enabledFeatures: [],
+        },
+      } }));
+    } else if (message.method === "plugin.activate" || message.method === "plugin.deactivate") {
+      queueMicrotask(() => this.emit("message", { data: {
+        jsonrpc: "2.0",
+        id: message.id,
+        result: null,
+      } }));
+    }
+  }
+
+  start() {}
+  close() { this.emit("close"); }
+}
+
+test("browser host waits for preload and the installed plugin RPC listener", async () => {
+  const contents = new EventEmitter();
+  let resolveLoading;
+  let postedPort = false;
+  contents.loadURL = () => new Promise((resolve) => { resolveLoading = resolve; });
+  contents.postMessage = (_channel, _message, ports) => { postedPort = ports.length === 1; };
+  contents.setWindowOpenHandler = () => {};
+  let webRtcPolicy;
+  contents.setWebRTCIPHandlingPolicy = (policy) => { webRtcPolicy = policy; };
+  const pluginSession = new EventEmitter();
+  pluginSession.protocol = { handle() {}, unhandle() {} };
+  pluginSession.webRequest = {
+    onBeforeRequest() {},
+    onCompleted() {},
+    onErrorOccurred() {},
+  };
+  pluginSession.setPermissionCheckHandler = () => {};
+  pluginSession.setPermissionRequestHandler = () => {};
+  pluginSession.setDevicePermissionHandler = () => {};
+  let proxyOptions;
+  let networkEmulation;
+  pluginSession.setProxy = async (options) => { proxyOptions = options; };
+  pluginSession.enableNetworkEmulation = (options) => { networkEmulation = options; };
+  let windowOptions;
+  class FakeWindow extends EventEmitter {
+    constructor(options) {
+      super();
+      windowOptions = options;
+      this.webContents = contents;
+    }
+    isDestroyed() { return false; }
+    destroy() {}
+  }
+  const port1 = new FakePort();
+  const port2 = new FakePort();
+  const onBeforeMessage = () => {};
+  let processReadyCalls = 0;
+  let sessionDisposed = false;
+  const runtime = new BrowserPluginRuntime({
+    electron: {
+      BrowserWindow: FakeWindow,
+      MessageChannelMain: class { constructor() { this.port1 = port1; this.port2 = port2; } },
+      session: { fromPartition: () => pluginSession },
+    },
+    protocol: {
+      registerSession: () => ({ dispose() { sessionDisposed = true; } }),
+      registerRuntime: () => ({
+        token: "runtime-token",
+        url: "netcatty-plugin://runtime-token/index.html",
+        dispose() {},
+      }),
+    },
+    plugin: {
+      id: "com.example.browser-runtime",
+      manifest: { main: { browser: "dist/index.js" } },
+    },
+    packageRoot: "/plugins/com.example.browser-runtime/1.0.0/package",
+    preloadPath: "/runtime/browserPreload.cjs",
+    handlers: {},
+    onBeforeMessage,
+    onProcessReady: () => { processReadyCalls += 1; },
+  });
+
+  const started = runtime.start({
+    pluginId: "com.example.browser-runtime",
+    pluginVersion: "1.0.0",
+    netcattyVersion: "0.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+    enabledFeatures: [],
+    environment: { locale: "en" },
+  }, {
+    getActivationEnvironment: () => ({ locale: "zh-CN", theme: "dark" }),
+  });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(processReadyCalls, 1);
+  contents.emit("ipc-message", {}, "netcatty-plugin:preload-ready");
+  resolveLoading();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(postedPort, true);
+  assert.equal(port1.sent.length, 0, "initialize must wait until the peer installs its RPC listener");
+
+  contents.emit("ipc-message", {}, "netcatty-plugin:runtime-connected");
+  const initialized = await started;
+  assert.equal(initialized.pluginId, "com.example.browser-runtime");
+  assert.equal(runtime.router.onBeforeMessage, onBeforeMessage);
+  assert.deepEqual(port1.sent.map((message) => message.method), ["plugin.initialize", "plugin.activate"]);
+  assert.deepEqual(port1.sent.find((message) => message.method === "plugin.activate").params, {
+    environment: { locale: "zh-CN", theme: "dark" },
+  });
+  const transferable = new ArrayBuffer(8);
+  runtime.router.send({ type: "transfer-test", transferable }, [transferable]);
+  assert.deepEqual(port1.transferLists.at(-1), [transferable]);
+  assert.equal(windowOptions.webPreferences.sandbox, true);
+  assert.equal(windowOptions.webPreferences.nodeIntegration, false);
+  assert.equal(windowOptions.webPreferences.contextIsolation, true);
+  assert.equal(proxyOptions.mode, "fixed_servers");
+  assert.equal(proxyOptions.proxyBypassRules, "<-loopback>");
+  assert.equal(webRtcPolicy, "disable_non_proxied_udp");
+  assert.deepEqual(networkEmulation, { offline: true });
+  let downloadPrevented = false;
+  pluginSession.emit("will-download", { preventDefault() { downloadPrevented = true; } });
+  assert.equal(downloadPrevented, true);
+  await runtime.stop();
+  assert.equal(sessionDisposed, true);
+  assert.doesNotThrow(() => port1.emit("message", { data: {
+    jsonrpc: "2.0",
+    method: "late.notification",
+  } }));
+});
+
+test("browser console levels and source paths are normalized without runtime tokens", () => {
+  assert.equal(normalizeConsoleLevel("error"), "error");
+  assert.equal(normalizeConsoleLevel("warning"), "warn");
+  assert.equal(normalizeConsoleLevel("debug"), "debug");
+  assert.equal(normalizeConsoleLevel(3), "error");
+  assert.equal(normalizeConsoleLevel(2), "warn");
+  assert.equal(normalizeConsoleLevel(1), "info");
+  assert.equal(
+    sanitizePluginSource("netcatty-plugin://secret-runtime-token/package/dist/index.js"),
+    "/package/dist/index.js",
+  );
+});
+
+test("aborted browser startup cannot create a window after proxy setup resumes", async () => {
+  let releaseProxy;
+  const proxyBlocked = new Promise((resolve) => { releaseProxy = resolve; });
+  const pluginSession = new EventEmitter();
+  pluginSession.protocol = { handle() {}, unhandle() {} };
+  pluginSession.setProxy = () => proxyBlocked;
+  let windows = 0;
+  const runtime = new BrowserPluginRuntime({
+    electron: {
+      BrowserWindow: class { constructor() { windows += 1; } },
+      MessageChannelMain: class {},
+      session: { fromPartition: () => pluginSession },
+    },
+    protocol: {
+      registerSession: () => ({ dispose() {} }),
+      registerRuntime: () => ({ token: "token", dispose() {} }),
+    },
+    plugin: {
+      id: "com.example.cancelled-browser",
+      manifest: { main: { browser: "dist/index.js" } },
+    },
+    packageRoot: "/plugins/cancelled/package",
+    preloadPath: "/runtime/browserPreload.cjs",
+    handlers: {},
+  });
+  const controller = new AbortController();
+  const starting = runtime.start({}, { signal: controller.signal });
+  await new Promise((resolve) => setImmediate(resolve));
+  controller.abort(new Error("cancelled"));
+  await runtime.stop();
+  releaseProxy();
+  await assert.rejects(starting, /cancelled/);
+  assert.equal(windows, 0);
+});