[Init] Initial commit - NetMesh terminal manager

electron/plugins/networkBroker.test.cjs

@@ -0,0 +1,171 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const {
+  PluginNetworkBroker,
+  MAX_NETWORK_BODY_BYTES,
+  MAX_NETWORK_HEADER_BYTES,
+} = require("./networkBroker.cjs");
+const { RPC_ERRORS } = require("./rpcRouter.cjs");
+
+function runtimeContext() {
+  return {
+    pluginId: "com.example.network",
+    pluginVersion: "1.0.0",
+    runtimeId: "runtime-1",
+    runtimeKind: "browser",
+    manifest: { permissions: { optional: ["network"] } },
+    signal: new AbortController().signal,
+    assertActive: async () => {},
+  };
+}
+
+test("network broker strips cookies, bounds responses, and charges decoded bytes", async () => {
+  const calls = [];
+  const charged = [];
+  const broker = new PluginNetworkBroker({
+    fetch: async (url, options) => {
+      calls.push({ url: String(url), options });
+      return new Response("hello", {
+        status: 200,
+        headers: { "content-type": "text/plain", "set-cookie": "secret=1" },
+      });
+    },
+    permissionEngine: { authorize: async () => {} },
+    quotaManager: { chargeBytes: (...args) => charged.push(args) },
+  });
+  const response = await broker.request({
+    url: "https://example.com/data",
+    headers: { accept: "text/plain" },
+  }, runtimeContext());
+  assert.equal(calls[0].options.credentials, "omit");
+  assert.equal(calls[0].options.redirect, "manual");
+  assert.equal(response.headers["set-cookie"], undefined);
+  assert.equal(Buffer.from(response.body.data, "base64").toString(), "hello");
+  assert.deepEqual(charged, [["runtime-1", "network", 5]]);
+});
+
+test("every redirect origin is authorized and cross-origin credentials are stripped", async () => {
+  const calls = [];
+  const authorized = [];
+  const broker = new PluginNetworkBroker({
+    fetch: async (url, options) => {
+      calls.push({ url: String(url), options });
+      if (calls.length === 1) {
+        return new Response(null, { status: 302, headers: { location: "https://other.example/final" } });
+      }
+      return new Response("ok", { status: 200 });
+    },
+    permissionEngine: { authorize: async (_context, descriptor) => authorized.push(descriptor) },
+  });
+  await broker.request({
+    url: "https://first.example/start",
+    headers: { authorization: "Bearer host-secret", "x-request-id": "one" },
+  }, runtimeContext());
+  assert.equal(authorized[0].resources[0], "https://other.example");
+  assert.equal(calls[1].options.headers.authorization, undefined);
+  assert.equal(calls[1].options.headers["x-request-id"], "one");
+});
+
+test("HTTP redirect method semantics do not replay POST bodies on 302", async () => {
+  const calls = [];
+  const charges = [];
+  const broker = new PluginNetworkBroker({
+    fetch: async (_url, options) => {
+      calls.push(options);
+      if (calls.length === 1) return new Response(null, { status: 302, headers: { location: "/done" } });
+      return new Response("ok");
+    },
+    permissionEngine: { authorize: async () => {} },
+    quotaManager: { chargeBytes: (...args) => charges.push(args) },
+  });
+  await broker.request({
+    url: "https://example.com/start",
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: { encoding: "utf8", data: "{}" },
+  }, runtimeContext());
+  assert.equal(calls[1].method, "GET");
+  assert.equal(calls[1].body, undefined);
+  assert.equal(calls[1].headers["content-type"], undefined);
+  assert.deepEqual(charges, [
+    ["runtime-1", "network", 2],
+    ["runtime-1", "network", 2],
+  ], "the request body and final response are both charged");
+});
+
+test("network redirects reject embedded credentials before authorization or fetch", async () => {
+  let calls = 0;
+  let authorizations = 0;
+  const broker = new PluginNetworkBroker({
+    fetch: async () => {
+      calls += 1;
+      return new Response(null, {
+        status: 302,
+        headers: { location: "https://user:password@other.example/private" },
+      });
+    },
+    permissionEngine: { authorize: async () => { authorizations += 1; } },
+  });
+  await assert.rejects(
+    broker.request({ url: "https://first.example/start" }, runtimeContext()),
+    /cannot contain credentials/,
+  );
+  assert.equal(calls, 1);
+  assert.equal(authorizations, 0);
+});
+
+test("network request validation rejects transport headers, credentials, and non-canonical bodies", () => {
+  const broker = new PluginNetworkBroker({
+    fetch: async () => new Response(),
+    permissionEngine: { authorize: async () => {} },
+  });
+  assert.throws(() => broker.validate({
+    url: "https://example.com",
+    headers: { cookie: "secret=1" },
+  }), /forbidden/);
+  assert.throws(() => broker.validate({ url: "https://user:pass@example.com" }), /credentials/);
+  assert.throws(() => broker.validate({
+    url: "https://example.com",
+    method: "POST",
+    body: { encoding: "base64", data: "YQ" },
+  }), /not canonical/);
+  assert.throws(() => broker.validate({
+    url: "https://example.com",
+    headers: Object.fromEntries(Array.from({ length: 9 }, (_, index) => (
+      [`x-budget-${index}`, "x".repeat(MAX_NETWORK_HEADER_BYTES / 8)]
+    ))),
+  }), /headers are too large/);
+  assert.throws(() => broker.validate({
+    url: "https://example.com",
+    headers: { "x-control": "before\0after" },
+  }), /header value is invalid/);
+});
+
+test("network response streaming stops above the byte cap", async () => {
+  const broker = new PluginNetworkBroker({
+    fetch: async () => new Response("small", {
+      headers: { "content-length": String(MAX_NETWORK_BODY_BYTES + 1) },
+    }),
+    permissionEngine: { authorize: async () => {} },
+  });
+  await assert.rejects(
+    broker.request({ url: "https://example.com" }, runtimeContext()),
+    (error) => error.code === RPC_ERRORS.resourceExhausted,
+  );
+});
+
+test("network broker reports its own timeout as a stable deadline error", async () => {
+  const broker = new PluginNetworkBroker({
+    fetch: async (_url, options) => new Promise((_resolve, reject) => {
+      options.signal.addEventListener("abort", () => reject(options.signal.reason), { once: true });
+    }),
+    permissionEngine: { authorize: async () => {} },
+  });
+  await assert.rejects(
+    broker.request({ url: "https://example.com", timeoutMs: 5 }, runtimeContext()),
+    (error) => error.code === RPC_ERRORS.deadlineExceeded,
+  );
+});