fix: 分离日常发布与首次初始化（09-09-existing-deploy-seed-separation）

server/tests/unit/scripts/deploy-init.test.js

@@ -0,0 +1,142 @@
+const { runInitialization, inspectRequiredConfiguration } = require("../../../src/scripts/deploy-init");
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+const fs = require("node:fs");
+const YAML = require("yaml");
+const os = require("node:os");
+
+const checks = [
+  { code: "expense_types", count: 2 },
+  { code: "approval_rules", count: 1 },
+  { code: "reimbursement_workflow", count: 1 },
+];
+
+describe("deployment init mode separation", () => {
+  it.each(["valid", "missing", "unsafe_default", "wrong_service"])("enforces the init-only environment contract: %s", (scenario) => {
+    const root = path.resolve(__dirname, "../../../..");
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "hyb-seed-env-"));
+    try {
+      let content = fs.readFileSync(path.join(root, "deploy/trialrun/docker-compose.yml"), "utf8");
+      if (scenario === "missing") content = content.replace('      DEPLOY_DATA_MODE: ${DEPLOY_DATA_MODE:-}\n', "");
+      if (scenario === "unsafe_default") content = content.replace('${DEPLOY_DATA_MODE:-}', '${DEPLOY_DATA_MODE:-initialize}');
+      if (scenario === "wrong_service") content = content.replace("      NODE_ENV: production", "      NODE_ENV: production\n      DEPLOY_DATA_MODE: existing");
+      const file = path.join(directory, "compose.yml");
+      fs.writeFileSync(file, content);
+      const result = spawnSync(process.execPath, [path.join(root, "deploy/trialrun/validate-env-contract.js")], {
+        env: { ...process.env, ENV_CONTRACT_COMPOSE_PATH: file }, encoding: "utf8",
+      });
+      expect(result.status).toBe(scenario === "valid" ? 0 : 1);
+      if (scenario !== "valid") expect(result.stdout + result.stderr).toContain("DEPLOY_DATA_MODE");
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+
+  it.each(["existing", "initialize"])("executes the complete %s path in order", async (mode) => {
+    const calls = [];
+    const report = vi.fn();
+    await runInitialization({
+      mode, report,
+      runCommand: async (command, args) => calls.push(args.join(" ")),
+      checkConfiguration: async () => { calls.push("check"); return checks; },
+    });
+    expect(calls).toEqual([
+      '-e require("./src/config").getConfig()',
+      "run prisma:migrate:deploy",
+      ...(mode === "initialize" ? ["run seed:config", "run seed:trialrun"] : []),
+      "check",
+    ]);
+    expect(report).toHaveBeenLastCalledWith({ status: "INIT_PASS", mode, checks });
+  });
+
+  it.each([undefined, "", "repair", " existing", "INITIALIZE"])("rejects invalid mode %s before any access", async (mode) => {
+    const runCommand = vi.fn();
+    const checkConfiguration = vi.fn();
+    await expect(runInitialization({ mode, runCommand, checkConfiguration })).rejects.toThrow("deployment.data_mode_required");
+    expect(runCommand).not.toHaveBeenCalled();
+    expect(checkConfiguration).not.toHaveBeenCalled();
+  });
+
+  it.each([0, 1, 2, 3])("stops initialize when subcommand %s fails", async (failureIndex) => {
+    const runCommand = vi.fn().mockImplementation(async () => {
+      if (runCommand.mock.calls.length === failureIndex + 1) throw new Error("synthetic_failure");
+    });
+    const checkConfiguration = vi.fn();
+    const report = vi.fn();
+    await expect(runInitialization({ mode: "initialize", runCommand, checkConfiguration, report })).rejects.toThrow("synthetic_failure");
+    expect(runCommand).toHaveBeenCalledTimes(failureIndex + 1);
+    expect(checkConfiguration).not.toHaveBeenCalled();
+    expect(report.mock.calls.some(([value]) => value.status === "INIT_PASS")).toBe(false);
+  });
+
+  it.each(checks.map((check) => check.code))("stops for missing %s without repair", async (missingCode) => {
+    const runCommand = vi.fn();
+    const report = vi.fn();
+    await expect(runInitialization({
+      mode: "existing", runCommand, report,
+      checkConfiguration: async () => checks.map((check) => ({ ...check, count: check.code === missingCode ? 0 : check.count })),
+    })).rejects.toThrow("deployment.required_configuration_missing");
+    expect(runCommand).toHaveBeenCalledTimes(2);
+    expect(report.mock.calls.some(([value]) => value.status === "INIT_PASS")).toBe(false);
+  });
+
+  it("does not succeed or seed on a read failure", async () => {
+    const runCommand = vi.fn();
+    const report = vi.fn();
+    await expect(runInitialization({
+      mode: "existing", runCommand, report,
+      checkConfiguration: async () => { throw new Error("query_failure"); },
+    })).rejects.toThrow("query_failure");
+    expect(runCommand).toHaveBeenCalledTimes(2);
+    expect(report.mock.calls.some(([value]) => value.status === "INIT_PASS")).toBe(false);
+  });
+
+  it("uses a bounded read-only transaction and the existing route predicates", async () => {
+    const transaction = {
+      $executeRaw: vi.fn().mockResolvedValue(0),
+      expenseType: { count: vi.fn().mockResolvedValue(4) },
+      approvalRule: { count: vi.fn().mockResolvedValue(2) },
+      workflowDefinition: { count: vi.fn().mockResolvedValue(1) },
+    };
+    const prisma = { $transaction: vi.fn(async (callback) => callback(transaction)) };
+    const result = await inspectRequiredConfiguration(prisma);
+    expect(transaction.$executeRaw.mock.calls[0][0].join("")).toBe("SET TRANSACTION READ ONLY");
+    expect(transaction.expenseType.count).toHaveBeenCalledWith({ where: { enabled: true } });
+    expect(transaction.approvalRule.count).toHaveBeenCalledWith({ where: { enabled: true } });
+    expect(transaction.workflowDefinition.count).toHaveBeenCalledWith({ where: { entity_type: "reimbursement", is_active: true } });
+    expect(prisma.$transaction.mock.calls[0][1]).toEqual({ isolationLevel: "RepeatableRead", maxWait: 5000, timeout: 10000 });
+    expect(result.map((check) => check.count)).toEqual([4, 2, 1]);
+  });
+
+  it("shares one entry with Compose and has no implicit initialize default", () => {
+    const root = path.resolve(__dirname, "../../../..");
+    const compose = YAML.parse(fs.readFileSync(path.join(root, "deploy/trialrun/docker-compose.yml"), "utf8"));
+    expect(compose.services.init.command).toEqual(["cd /app/server && npm run deploy:init"]);
+    expect(compose.services.init.environment.DEPLOY_DATA_MODE).toBe("${DEPLOY_DATA_MODE:-}");
+    const result = spawnSync(process.execPath, ["src/scripts/deploy-init.js"], {
+      cwd: path.join(root, "server"),
+      env: { PATH: process.env.PATH, DEPLOY_DATA_MODE: "" }, encoding: "utf8",
+    });
+    expect(result.status).toBe(1);
+    expect(JSON.parse(result.stderr).code).toBe("deployment.data_mode_required");
+    expect(result.stdout).toBe("");
+  });
+
+  it("passes the whole Compose command to the shell and preserves child failure", () => {
+    const root = path.resolve(__dirname, "../../../..");
+    const compose = YAML.parse(fs.readFileSync(path.join(root, "deploy/trialrun/docker-compose.yml"), "utf8"));
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "hyb-seed-argv-"));
+    try {
+      fs.writeFileSync(path.join(directory, "npm"), '#!/bin/sh\n[ "$1" = run ] && [ "$2" = deploy:init ] && [ "$DEPLOY_DATA_MODE" = existing ] || exit 99\nprintf ENTRY_REACHED\nexit 17\n', { mode: 0o700 });
+      const command = compose.services.init.command.map((argument) => argument.replace("/app/server", directory));
+      const [executable, ...argumentsBeforeCommand] = compose.services.init.entrypoint;
+      const result = spawnSync(executable, [...argumentsBeforeCommand, ...command], {
+        env: { PATH: directory + ":" + process.env.PATH, DEPLOY_DATA_MODE: "existing" }, encoding: "utf8",
+      });
+      expect(result.stdout).toBe("ENTRY_REACHED");
+      expect(result.status).toBe(17);
+    } finally {
+      fs.rmSync(directory, { recursive: true, force: true });
+    }
+  });
+});