mnote/scripts/desktop-hot.test.js

const assert = require("node:assert");
const { spawn } = require("node:child_process");
const net = require("node:net");
const { test } = require("node:test");
const {
  buildDefaultOpenHubCommand,
  resolveBackendExecutable,
  ensurePortFree,
  isPortFree,
  resolveOpenHubHealthPlan,
  resolveRuntimePlan,
  shouldStartBackend,
  shouldStartOpenHub,
} = require("./desktop-hot.js");

function findFreePort() {
  return new Promise((resolve, reject) => {
    const server = net.createServer();
    server.listen(0, "127.0.0.1", () => {
      const address = server.address();
      if (!address || typeof address === "string") {
        server.close(() => reject(new Error("无法分配测试端口")));
        return;
      }
      const port = address.port;
      server.close(() => resolve(port));
    });
    server.on("error", reject);
  });
}

function startPythonListener(port) {
  const pythonBin = resolveBackendExecutable("PYTHON_BIN", "python");
  const child = spawn(
    pythonBin,
    [
      "-c",
      `
import socket
import time
import threading
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("127.0.0.1", ${port}))
server.listen(16)
def accept_loop():
    while True:
        conn, _addr = server.accept()
        conn.close()
threading.Thread(target=accept_loop, daemon=True).start()
print("ready", flush=True)
while True:
    time.sleep(1)
      `,
    ],
    {
      stdio: ["ignore", "pipe", "pipe"],
    },
  );

  return new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      child.kill("SIGKILL");
      reject(new Error("测试监听进程启动超时"));
    }, 3000);

    child.stdout.on("data", (chunk) => {
      if (chunk.toString("utf8").includes("ready")) {
        clearTimeout(timeout);
        resolve(child);
      }
    });

    child.on("error", (error) => {
      clearTimeout(timeout);
      reject(error);
    });
  });
}

function waitForExit(child, timeoutMs = 3000) {
  if (child.exitCode !== null || child.signalCode !== null) {
    return Promise.resolve();
  }

  return new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      child.off("exit", onExit);
      reject(new Error(`进程 ${child.pid} 未在 ${timeoutMs}ms 内退出`));
    }, timeoutMs);
    const onExit = () => {
      clearTimeout(timeout);
      resolve();
    };
    child.once("exit", onExit);
  });
}

test("ensurePortFree 在非 Windows 平台能释放后端监听进程", async (t) => {
  if (process.platform === "win32") {
    t.skip("该用例只覆盖 Linux/macOS 分支");
    return;
  }

  const port = await findFreePort();
  const child = await startPythonListener(port);

  t.after(() => {
    if (!child.killed) {
      child.kill("SIGKILL");
    }
  });

  assert.equal(await isPortFree("127.0.0.1", port), false);
  const ok = await ensurePortFree(port, "backend");
  assert.equal(ok, true);
  assert.equal(await isPortFree("127.0.0.1", port), true);
  await waitForExit(child);
});

test("默认热启动计划只使用 mnote-web 作为 3000 owner", () => {
  const plan = resolveRuntimePlan({
    FRONTEND_PORT: "3000",
  });

  assert.equal(plan.skipGateway, false);
  assert.equal(plan.publicPort, 3000);
  assert.equal(plan.mnoteWebCommand, "cargo run -p mnote-web --bin mnote-web");
  assert.deepEqual(plan.mnoteWebEnv, {
    MNOTE_WEB_BIND: "0.0.0.0:3000",
    MNOTE_WEB_PUBLIC_BIND: "127.0.0.1:3000",
    MNOTE_OPENCODE_BASE_URL: "http://127.0.0.1:4096",
    MNOTE_OPENHUB_BASE_URL: "http://127.0.0.1:18080",
    MNOTE_OPENHUB_DISABLE_GIT_SNAPSHOT_RESTORE: "1",
  });
});

test("默认跳过 FastAPI 后端，只有显式开启时才启动", () => {
  assert.equal(shouldStartBackend({}), false);
  assert.equal(shouldStartBackend({ ENABLE_BACKEND: "1" }), true);
  assert.equal(shouldStartBackend({ ENABLE_BACKEND: "true" }), true);
  assert.equal(shouldStartBackend({ BACKEND_CMD: "custom-backend" }), true);
  assert.equal(shouldStartBackend({ ENABLE_BACKEND: "1", SKIP_BACKEND: "1" }), false);
});

test("OpenHub FastAPI 默认跳过，显式开启或命令覆盖时才启动", () => {
  assert.equal(shouldStartOpenHub({}), false);
  assert.equal(shouldStartOpenHub({ ENABLE_OPENHUB: "1" }), true);
  assert.equal(shouldStartOpenHub({ ENABLE_OPENHUB: "true" }), true);
  assert.equal(shouldStartOpenHub({ OPENHUB_CMD: "custom-openhub" }), true);
  assert.equal(shouldStartOpenHub({ ENABLE_OPENHUB: "1", SKIP_OPENHUB: "1" }), false);
});

test("OpenHub health plan 包含 FastAPI、Redis、opencode 和默认关闭 Git snapshot/restore", () => {
  const plan = resolveOpenHubHealthPlan({
    ENABLE_OPENHUB: "1",
    REQUIRE_OPENHUB_HEALTH: "1",
    OPENHUB_PORT: "18081",
    OPENCODE_PORT: "4097",
    OPENHUB_REDIS_HEALTH_URL: "http://127.0.0.1:6379/health",
  });

  assert.equal(plan.enabled, true);
  assert.equal(plan.openhub.url, "http://127.0.0.1:18081/health");
  assert.equal(plan.openhub.required, true);
  assert.equal(plan.redis.url, "http://127.0.0.1:6379/health");
  assert.equal(plan.redis.skipped, false);
  assert.equal(plan.opencode.url, "http://127.0.0.1:4097/global/health");
  assert.deepEqual(plan.gitSnapshotRestore, {
    env: "MNOTE_OPENHUB_DISABLE_GIT_SNAPSHOT_RESTORE",
    value: "1",
    defaultDisabled: true,
  });
});

test("OpenHub 默认命令只启动 FastAPI，不包含 snapshot/restore 写操作", () => {
  const command = buildDefaultOpenHubCommand(18082);
  assert.match(command, /uvicorn app\.main:app/);
  assert.match(command, /--port 18082/);
  assert.doesNotMatch(command, /snapshot|restore|revert|kill-port/i);
});