[Init] Initial commit - NetMesh terminal manager

electron/bridges/httpNetworkProxyBridge.test.cjs

@@ -0,0 +1,172 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  buildElectronProxyConfigFromPayload,
+  applyNodeProxyEnv,
+  normalizeProxySettingsPayload,
+} = require("./httpNetworkProxyBridge.cjs");
+
+test("normalizeProxySettingsPayload defaults to system", () => {
+  assert.deepEqual(normalizeProxySettingsPayload(undefined), {
+    mode: "system",
+    url: "",
+    bypass: "<local>",
+  });
+});
+
+test("buildElectronProxyConfigFromPayload maps custom mode", () => {
+  assert.deepEqual(
+    buildElectronProxyConfigFromPayload({
+      mode: "custom",
+      url: "http://127.0.0.1:7890",
+      bypass: "localhost",
+    }),
+    {
+      mode: "fixed_servers",
+      proxyRules: "http://127.0.0.1:7890",
+      proxyBypassRules: "localhost",
+    },
+  );
+});
+
+test("applyNodeProxyEnv sets and clears process.env for custom/direct", () => {
+  const { resetProxyEnvOwnershipForTests } = require("./httpNetworkProxyBridge.cjs");
+  resetProxyEnvOwnershipForTests();
+
+  const env = {
+    HTTP_PROXY: "stale",
+    HTTPS_PROXY: "stale",
+    NO_PROXY: "stale",
+    http_proxy: "stale",
+    https_proxy: "stale",
+    no_proxy: "stale",
+  };
+
+  applyNodeProxyEnv(
+    { mode: "custom", url: "http://proxy:1", bypass: "a,b" },
+    env,
+  );
+  assert.equal(env.HTTP_PROXY, "http://proxy:1");
+  assert.equal(env.HTTPS_PROXY, "http://proxy:1");
+  assert.equal(env.NO_PROXY, "a,b");
+  assert.equal(env.http_proxy, "http://proxy:1");
+
+  applyNodeProxyEnv({ mode: "direct", url: "", bypass: "<local>" }, env);
+  assert.equal(env.HTTP_PROXY, undefined);
+  assert.equal(env.HTTPS_PROXY, undefined);
+  assert.equal(env.NO_PROXY, undefined);
+  assert.equal(env.http_proxy, undefined);
+});
+
+test("applyNodeProxyEnv restores prior env when returning to system after custom", () => {
+  const { resetProxyEnvOwnershipForTests } = require("./httpNetworkProxyBridge.cjs");
+  resetProxyEnvOwnershipForTests();
+
+  const env = {
+    HTTP_PROXY: "os-proxy",
+    HTTPS_PROXY: "os-proxy",
+    NO_PROXY: "localhost",
+  };
+
+  applyNodeProxyEnv(
+    { mode: "custom", url: "http://user:pass@proxy:1", bypass: "a" },
+    env,
+  );
+  // Credentials must not be written into process.env.
+  assert.equal(env.HTTP_PROXY, "http://proxy:1");
+  assert.equal(env.HTTPS_PROXY, "http://proxy:1");
+
+  applyNodeProxyEnv({ mode: "system", url: "", bypass: "<local>" }, env);
+  assert.equal(env.HTTP_PROXY, "os-proxy");
+  assert.equal(env.HTTPS_PROXY, "os-proxy");
+  assert.equal(env.NO_PROXY, "localhost");
+});
+
+test("normalizeProxySettingsPayload strips scheme-less proxy credentials", () => {
+  assert.equal(
+    normalizeProxySettingsPayload({
+      mode: "custom",
+      url: "user:secret@proxy.example:8080",
+      bypass: "<local>",
+    }).url,
+    "proxy.example:8080",
+  );
+});
+
+test("buildTerminalProcessEnv restores launch-time proxy env under direct/custom", () => {
+  const {
+    applyNodeProxyEnv,
+    buildTerminalProcessEnv,
+    resetProxyEnvOwnershipForTests,
+  } = require("./httpNetworkProxyBridge.cjs");
+  resetProxyEnvOwnershipForTests();
+
+  const env = {
+    HTTP_PROXY: "launch-proxy",
+    HTTPS_PROXY: "launch-proxy",
+    NO_PROXY: "localhost",
+    PATH: "/usr/bin",
+  };
+
+  applyNodeProxyEnv({ mode: "direct", url: "", bypass: "<local>" }, env);
+  assert.equal(env.HTTP_PROXY, undefined);
+
+  const terminalEnv = buildTerminalProcessEnv(env);
+  assert.equal(terminalEnv.HTTP_PROXY, "launch-proxy");
+  assert.equal(terminalEnv.HTTPS_PROXY, "launch-proxy");
+  assert.equal(terminalEnv.NO_PROXY, "localhost");
+  assert.equal(terminalEnv.PATH, "/usr/bin");
+  // App-level process.env remains direct (cleared) for Node HTTP clients.
+  assert.equal(env.HTTP_PROXY, undefined);
+});
+
+test("empty custom mode applies as system for Electron/env", () => {
+  assert.deepEqual(
+    buildElectronProxyConfigFromPayload({ mode: "custom", url: "", bypass: "<local>" }),
+    { mode: "system" },
+  );
+});
+
+test("applyHttpNetworkProxy serializes so older setProxy cannot overwrite newer", async () => {
+  const {
+    applyHttpNetworkProxy,
+    getCurrentProxySettings,
+    resetProxyEnvOwnershipForTests,
+  } = require("./httpNetworkProxyBridge.cjs");
+  resetProxyEnvOwnershipForTests();
+
+  const applied = [];
+  let releaseFirst;
+  const firstGate = new Promise((resolve) => {
+    releaseFirst = resolve;
+  });
+
+  const session = {
+    async setProxy(config) {
+      applied.push(config);
+      if (applied.length === 1) {
+        await firstGate;
+      }
+    },
+  };
+
+  const first = applyHttpNetworkProxy(
+    { mode: "custom", url: "http://first:1", bypass: "<local>" },
+    { session, env: {} },
+  );
+  // Let first reach its gate inside setProxy.
+  await new Promise((r) => setImmediate(r));
+  const second = applyHttpNetworkProxy(
+    { mode: "direct", url: "", bypass: "<local>" },
+    { session, env: {} },
+  );
+
+  releaseFirst();
+  const [firstResult, secondResult] = await Promise.all([first, second]);
+
+  assert.equal(firstResult.superseded, true);
+  assert.equal(secondResult.success, true);
+  assert.equal(getCurrentProxySettings().mode, "direct");
+  assert.deepEqual(applied.at(-1), { mode: "direct" });
+});