Netcatty/electron/hostBrowser/hostBrowserManager.test.cjs

"use strict";

const assert = require("node:assert/strict");
const test = require("node:test");
const { readFileSync } = require("node:fs");
const vm = require("node:vm");
const { normalizeBrowserUrl, pdfDownloadHeaders } = require("./hostBrowserManager.cjs");

test("page tabs accept invalid TLS certificates and suppress only accepted navigation errors", async () => {
  const { EventEmitter } = require("node:events");
  const source = readFileSync(require.resolve("./hostBrowserManager.cjs"), "utf8");
  const start = source.indexOf("const addTab =");
  const end = source.indexOf("const stopTunnel =", start);
  assert.ok(start > 0 && end > start);
  const chromeContents = new EventEmitter();
  const record = { tabs: new Map(), navigations: new Map(), pageSession: {}, chromeContents, route: "connected" };
  const loads = [];
  const addTab = vm.runInNewContext(`${source.slice(start, end)};addTab;`, {
    MAX_TABS: 32, randomUUID: require("node:crypto").randomUUID,
    displayTab() {},
    WebContentsView: class {
      constructor({ webPreferences }) {
        assert.equal(webPreferences.session, record.pageSession);
        assert.equal(webPreferences.webSecurity, true);
        const contents = this.webContents = new EventEmitter();
        contents.id = record.tabs.size + 1;
        contents.setWebRTCIPHandlingPolicy = () => {};
        contents.setWindowOpenHandler = () => {};
        contents.loadURL = async (url) => {
          for (const error of ["net::ERR_CERT_AUTHORITY_INVALID", "net::ERR_CERT_DATE_INVALID"]) {
            const calls = [];
            contents.emit("certificate-error", { preventDefault: () => calls.push("preventDefault") },
              url, error, {}, (allowed) => calls.push(allowed));
            assert.deepEqual(calls, ["preventDefault", true]);
          }
        };
        const loadURL = contents.loadURL;
        contents.loadURL = (url) => { const load = loadURL(url); loads.push(load); return load; };
      }
    },
  });
  addTab(record, "https://172.16.0.235/");
  addTab(record, "https://device.test/");
  await Promise.all(loads);
  assert.equal(loads.length, 2);
  assert.equal(chromeContents.listenerCount("certificate-error"), 0);

  const commandStart = source.indexOf("const runCommand =");
  const commandEnd = source.indexOf('ipcMain.handle("netcatty:host-browser:command"', commandStart);
  assert.ok(commandStart > 0 && commandEnd > commandStart);
  const runCommand = vm.runInNewContext(`${source.slice(commandStart, commandEnd)};runCommand;`, {
    getOwned: () => record, snapshot: () => record, displayTab() {}, normalizeBrowserUrl,
  });
  const contents = record.tabs.get(record.activeTabId).view.webContents;
  const certError = Object.assign(new Error("ERR_CERT_AUTHORITY_INVALID"), { code: "ERR_CERT_AUTHORITY_INVALID" });
  contents.loadURL = async (url) => {
    contents.emit("certificate-error", { preventDefault() {} }, url, "net::ERR_CERT_AUTHORITY_INVALID", {}, () => {});
    throw certError;
  };
  const command = { type: "navigate", url: "https://172.16.0.235/" };
  await assert.doesNotReject(runCommand({}, command));
  assert.equal(record.navigations.size, 0);
  // Acceptance belongs to one navigation; it must not hide a later failure.
  contents.loadURL = async () => { throw certError; };
  await assert.rejects(runCommand({}, command), (error) => error === certError);
  const networkError = Object.assign(new Error("ERR_CONNECTION_REFUSED"), { code: "ERR_CONNECTION_REFUSED" });
  contents.loadURL = async (url) => {
    contents.emit("certificate-error", { preventDefault() {} }, url, "net::ERR_CERT_AUTHORITY_INVALID", {}, () => {});
    throw networkError;
  };
  await assert.rejects(runCommand({}, command), (error) => error === networkError);
  assert.equal(record.navigations.size, 0);
});

test("PDF navigations download before the preview can buffer the response", () => {
  const headers = { "Content-Type": ["Application/PDF;charset=UTF-8"], "Content-Length": ["8933895"] };
  for (const resourceType of ["mainFrame", "subFrame"]) {
    assert.deepEqual(pdfDownloadHeaders({ resourceType, statusCode: 200, responseHeaders: headers }), {
      ...headers, "Content-Disposition": ["attachment"],
    });
  }
  assert.equal(headers["Content-Disposition"], undefined, "the original response headers are not mutated");
});

test("PDF downloads preserve the site's localized suggested filename", () => {
  const filename = "; filename=report.pdf; filename*=UTF-8''%E6%8A%A5%E5%91%8A.pdf";
  const headers = { "content-type": ["application/pdf"], "content-disposition": [`inline${filename}`] };
  assert.deepEqual(pdfDownloadHeaders({ resourceType: "mainFrame", statusCode: 200, responseHeaders: headers }), {
    ...headers, "content-disposition": [`attachment${filename}`],
  });
});

test("PDF policy leaves webpage requests, failed responses and explicit downloads alone", () => {
  const responseHeaders = { "content-type": ["application/pdf"] };
  const details = { resourceType: "mainFrame", statusCode: 200, responseHeaders };
  for (const resourceType of ["xhr", "object", "other", "script", "image"]) assert.equal(pdfDownloadHeaders({ ...details, resourceType }), undefined);
  for (const statusCode of [302, 404, 500]) assert.equal(pdfDownloadHeaders({ ...details, statusCode }), undefined);
  for (const mime of ["text/html", "image/png", "application/octet-stream"]) assert.equal(pdfDownloadHeaders({ ...details, responseHeaders: { "content-type": [mime] } }), undefined);
  assert.equal(pdfDownloadHeaders({ ...details, responseHeaders: { ...responseHeaders, "content-disposition": ["attachment; filename=report.pdf"] } }), undefined);
  assert.equal(pdfDownloadHeaders({ ...details, responseHeaders: undefined }), undefined);
});

test("browser addresses accept bare localhost and domain ports", () => {
  assert.equal(normalizeBrowserUrl("localhost:3000"), "http://localhost:3000/");
  assert.equal(normalizeBrowserUrl("localhost:3000/app"), "http://localhost:3000/app");
  assert.equal(normalizeBrowserUrl("127.0.0.1:8080"), "http://127.0.0.1:8080/");
  assert.equal(normalizeBrowserUrl("example.com:8080"), "https://example.com:8080/");
  assert.equal(normalizeBrowserUrl("https://example.com/app"), "https://example.com/app");
});

test("browser addresses keep rejecting external protocols and credentials", () => {
  for (const url of ["file:///etc/passwd", "javascript:alert(1)", "mailto:test@example.com", "https://user:password@example.com/"]) {
    assert.throws(() => normalizeBrowserUrl(url));
  }
});

test("late download notifications ignore closed browser chrome in a live terminal", () => {
  const source = readFileSync(require.resolve("./hostBrowserManager.cjs"), "utf8");
  const start = source.indexOf("const notifyDownloads =");
  const end = source.indexOf("const snapshot =", start);
  assert.ok(start > 0 && end > start);
  const record = {
    hostId: "host",
    win: { isDestroyed: () => false },
    chromeContents: {
      isDestroyed: () => true,
      send: () => { throw new Error("Object has been destroyed"); },
    },
    downloadsPanelOpen: false,
  };
  const notify = vm.runInNewContext(`${source.slice(start, end)};notifyDownloads;`, {
    downloadStore: { list: () => [] },
    windows: new Map([["closed", record]]),
  });
  assert.doesNotThrow(() => notify(record));
});

test("manager shutdown flushes download history after closing windows", () => {
  const source = readFileSync(require.resolve("./hostBrowserManager.cjs"), "utf8");
  const start = source.indexOf("closeAll: () => {");
  const end = source.indexOf("} };", start);
  assert.ok(start > 0 && end > start);
  const calls = [];
  const closeAll = vm.runInNewContext(`(() => {${source.slice(start + "closeAll: () => {".length, end)}})`, {
    unsubscribeTunnelStatus: () => calls.push("unsubscribe"),
    windows: new Map([[1, { embedded: true }]]),
    closeRecord: () => calls.push("close"),
    downloadStore: { flush: () => calls.push("flush") },
  });
  closeAll();
  assert.deepEqual(calls, ["unsubscribe", "close", "flush"]);
});

test("download handler defers only live progress, not pause or completion", () => {
  const { EventEmitter } = require("node:events");
  const path = require("node:path");
  const source = readFileSync(require.resolve("./hostBrowserManager.cjs"), "utf8");
  const start = source.indexOf("record.downloadHandler =");
  const end = source.indexOf('pageSession.on("will-download"', start);
  const calls = [];
  let previous;
  let now = 1000;
  const record = { route: "connected", embedded: true, downloads: new Map(), tabs: new Map([[1, { view: { webContents: "owned" } }]]) };
  vm.runInNewContext(source.slice(start, end), {
    record, path, randomUUID: () => "id", hostId: "host", app: { getPath: () => "/downloads" },
    reserveDownloadFile: () => ({ savePath: "/downloads/file", cleanupEmpty() {} }),
    downloadStore: { get: () => previous, upsert(row, options) { previous = row; calls.push({ row, options }); } },
    notifyDownloads() {}, Date: { now: () => now },
  });
  const item = Object.assign(new EventEmitter(), {
    paused: false, isPaused() { return this.paused; }, getFilename: () => "file", getURL: () => "https://example.test/file",
    getTotalBytes: () => 100, getReceivedBytes: () => 10, getSavePath: () => "/downloads/file", setSavePath() {},
  });
  record.downloadHandler({ preventDefault() { assert.fail("rejected owned download"); } }, item, "owned");
  assert.equal(calls[0].options, undefined);
  item.emit("updated", {}, "progressing");
  assert.equal(calls[1].options.deferProgress, true);
  now += 1;
  item.paused = true;
  item.emit("updated", {}, "progressing");
  assert.equal(calls[2].options.deferProgress, false, "pause bypasses the byte-progress throttle");
  item.emit("done", {}, "completed");
  assert.equal(calls[3].options, undefined);
  assert.equal(calls[3].row.status, "completed");
});