jui-tools-mcp-server 2.17.0 → 2.18.0

package/tests/tools_infra.test.ts

@@ -330,3 +330,211 @@ describe("a long problem list", () => {
     expect(out.problems.first[19].path).toBe("/nodes/19/category");
   });
 });
+
+/**
+ * Without `plan`, both tools answer exactly what they answered before plans existed (jsonui-mcp-server 6207831): the
+ * whole text, byte for byte, for every recorded output. Recorded once from that commit with RECORD_NO_PLAN=1; a
+ * change to these answers is a change to every agent that reads them, so it is made on purpose or not at all.
+ */
+describe("without plan, the answers are the ones before plans", () => {
+  const CASES: [string, string, number, Record<string, unknown>][] = [
+    ["validate ok", "validate-infra.ok.json", 0, {}],
+    ["validate errors", "validate-infra.errors.json", 1, {}],
+    ["validate unreadable", "validate-infra.unreadable.json", 2, {}],
+    ["cost month", "cost-infra.month.json", 0, {}],
+    ["cost month by node", "cost-infra.month-by-node.json", 0, { scenario: "sale", by: "node" }],
+    ["cost day", "cost-infra.day.json", 0, { date: "2026-11-03" }],
+    ["cost refused", "cost-infra.refused.json", 2, { scenario: "nope" }],
+  ];
+  const BEFORE = join(FIX, "answers-without-plan.json");
+
+  // the CLI's problems now carry short (the page's language) and detail; the summaries keep the English message
+  // only, so the answers above stay byte for byte — this arm is not empty only while the fixtures carry them
+  it("the recorded problems carry short and detail, which the answers leave out", () => {
+    const v = fixture("validate-infra.errors.json").problems;
+    expect(v.length).toBeGreaterThan(0);
+    expect(v.every((p: any) => typeof p.short === "string" && "detail" in p)).toBe(true);
+    expect(fixture("cost-infra.plan-bad.json").problems.every((p: any) => typeof p.short === "string")).toBe(true);
+    const before = JSON.parse(readFileSync(BEFORE, "utf-8"));
+    expect(before["validate errors"]).not.toMatch(/"short"|"detail"/);
+  });
+
+  it.each(CASES)("%s", async (label, file, code, params) => {
+    answer = { code, stdout: raw(file) };
+    const tool = label.startsWith("validate") ? "infra_validate" : "infra_cost";
+    const got = await harness.call(tool, { project_dir: projectDir, ...params });
+    if (process.env.RECORD_NO_PLAN) {
+      const all = existsSync(BEFORE) ? JSON.parse(readFileSync(BEFORE, "utf-8")) : {};
+      all[label] = got;
+      writeFileSync(BEFORE, JSON.stringify(all, null, 2) + "\n");
+      return;
+    }
+    expect(got).toBe(JSON.parse(readFileSync(BEFORE, "utf-8"))[label]);
+  });
+});
+
+/**
+ * Migration plans (jsonui-cli 2.3.20, --migration): the summaries read the keys the CLI promised, recorded from it —
+ * a plan that holds, one plan per migration.* code, and the cost's old / new / difference with and without the
+ * account. A key the output lacks is named, never summarised as an empty plan.
+ */
+describe("infra_validate with plan", () => {
+  it("a plan folder with nothing in it yet is a plan that is not ok, its read problem said (an empty folder lists none)", async () => {
+    answer = { code: 1, stdout: raw("validate-infra.plan-half.json") };
+    const out = await call("infra_validate", { plan: "half" });
+    expect(out.migrations).toHaveLength(1);
+    expect(out.migrations[0]).toMatchObject({ name: "half", ok: false, counts: {}, steps: 0, firstSteps: [] });
+    expect(out.migrations[0].problems.byCode).toEqual({ "read.unreadable": 1 });
+  });
+
+  it("passes --migration and summarises the plan: counts, steps in order, edges taken and added", async () => {
+    answer = { stdout: raw("validate-infra.plan-move.json") };
+    const out = await call("infra_validate", { plan: "move" });
+    expect(calls[0].args).toEqual(["validate", "infra", projectDir, "--json", "--migration", "move"]);
+    const [m] = fixture("validate-infra.plan-move.json").migrations;
+    expect(out.ok).toBe(true);
+    expect(out.migrations).toHaveLength(1);
+    expect(out.migrations[0]).toMatchObject({ name: "move", ok: true, counts: m.counts, steps: m.steps.length });
+    expect(out.migrations[0].problems.count).toBe(0);
+    expect(out.migrations[0].firstSteps.map((s: any) => [s.index, s.kind, s.node]))
+      .toEqual(m.steps.map((s: any) => [s.index, s.kind, s.node]));
+    // a step with no edge moved carries no empty lists
+    expect(out.migrations[0].firstSteps[0]).toEqual({ index: 1, kind: "replace", node: "db-prod" });
+    expect(out.migrations[0].firstSteps[2].edgesRemoved).toEqual(m.steps[2].edgesRemoved);
+  });
+
+  it("without plan, a room that has plans lists each", async () => {
+    answer = { stdout: raw("validate-infra.plans.json") };
+    const out = await call("infra_validate");
+    expect(calls[0].args).toEqual(["validate", "infra", projectDir, "--json"]);
+    expect(out.migrations.map((m: any) => m.name)).toEqual(["move"]);
+  });
+
+  it.each([
+    ["remove-missing", "migration.remove_missing"],
+    ["duplicate", "migration.duplicate"],
+    ["both", "migration.both"],
+    ["order-unknown", "migration.order_unknown"],
+    ["edge-end", "migration.edge_end"],
+    ["none", "migration.no_plan"],
+  ])("a plan with %s: exit 1 while the model is fine, and the answer shows why (%s)", async (name, code) => {
+    answer = { code: 1, stdout: raw(`validate-infra.plan-${name}.json`) };
+    const out = await call("infra_validate", { plan: name });
+    const rec = fixture(`validate-infra.plan-${name}.json`);
+    expect(rec.problems).toEqual([]);              // the model's own list is empty: only the plan says it
+    expect(out).toMatchObject({ ok: false, exit: 1, readable: true });
+    expect(out.problems.count).toBe(0);
+    expect(out.migrations[0].ok).toBe(false);
+    expect(out.migrations[0].problems.byCode).toEqual({ [code]: 1 });
+    const [p] = rec.migrations[0].problems;
+    expect(out.migrations[0].problems.first[0]).toEqual(
+      Object.fromEntries(["severity", "code", "file", "path", "message"].filter((k) => p[k] != null).map((k) => [k, p[k]])));
+  });
+
+  it.each(["name", "dir", "ok", "problems", "steps", "counts"])("names %s when a plan lacks it", async (key) => {
+    const data = fixture("validate-infra.plan-move.json");
+    delete data.migrations[0][key];
+    answer = { stdout: JSON.stringify(data) };
+    expect(await harness.call("infra_validate", { project_dir: projectDir, plan: "move" }))
+      .toMatch(new RegExp(`^Error: validate infra migration: the JSON has no "${key}"`));
+  });
+
+  it("with plan, an output with no migrations at all is a CLI these tools do not know", async () => {
+    answer = { stdout: raw("validate-infra.ok.json") };
+    expect(await harness.call("infra_validate", { project_dir: projectDir, plan: "move" }))
+      .toMatch(/^Error: validate infra --migration: the JSON has no "migrations"/);
+  });
+});
+
+describe("infra_cost with plan", () => {
+  it("passes --migration and answers old / new / difference, the biggest node changes first, and each step", async () => {
+    answer = { stdout: raw("cost-infra.plan-move.json") };
+    const out = await call("infra_cost", { plan: "move" });
+    expect(calls[0].args).toEqual(["cost", "infra", projectDir, "--json", "--migration", "move"]);
+    const rec = fixture("cost-infra.plan-move.json");
+    expect(out).toMatchObject({ ok: true, exit: 0, migration: "move", scenario: rec.scenario, dir: rec.dir,
+      scenarios: rec.scenarios, usd: { old: rec.old.usd, new: rec.new.usd, diff: rec.diff.usd },
+      byProvider: rec.byProvider, account: null, loadProblems: rec.problems,
+      priceWarnings: rec.prices.warnings, priceWarningCount: rec.prices.warningCount });
+    expect(out.newUnpriced).toEqual({ noPrice: rec.new.noPrice, noRule: rec.new.noRule, loadUndefined: rec.new.loadUndefined });
+    expect(out.oldUnpriced).toEqual({ noPrice: rec.old.noPrice, noRule: rec.old.noRule, loadUndefined: rec.old.loadUndefined });
+    // worker-prod is added with no price: its part is out of the difference, said by name and on its row
+    expect(rec.unpricedChanged).toEqual(["worker-prod"]);
+    expect(out.unpricedChanged).toEqual(rec.unpricedChanged);
+    expect(out.topChanges.find((n: any) => n.node === "worker-prod").unpriced).toBe(true);
+    expect(out.topChanges.find((n: any) => n.node === "db-prod").unpriced).toBe(false);
+    expect(out.steps).toEqual(rec.steps.map((s: any) => ({ index: s.index, node: s.node, usd: s.usd, diff: s.diff,
+      moved: s.moved, movedCount: s.moved.length })));
+    expect(out.topChanges[0].node).toBe("db-prod");
+    expect(out.topChanges.map((n: any) => n.change).sort()).toEqual(["added", "removed", "replaced"]);
+    expect(out.nodes).toMatchObject({ added: 1, replaced: 1, removed: 1 });
+  });
+
+  it("the biggest movement first whichever way, and a node the plan does not touch that moves with it is a change", async () => {
+    // shrink: the database shrinks (the biggest, a fall), api-prod goes, and batch-prod — untouched, after api-prod
+    // in the model — takes more of the account's free egress: "same", yet its month moves
+    answer = { stdout: raw("cost-infra.plan-shrink.json") };
+    const out = await call("infra_cost", { plan: "shrink" });
+    const rec = fixture("cost-infra.plan-shrink.json");
+    const batch = rec.byNode.find((n: any) => n.node === "batch-prod");
+    expect(batch.change).toBe("same");
+    expect(batch.diff).toBeLessThan(0);
+    expect(out.topChanges[0]).toMatchObject({ node: "db-prod", change: "replaced" });
+    expect(out.topChanges[0].diff).toBeLessThan(0);
+    const sizes = out.topChanges.map((n: any) => Math.abs(n.diff));
+    expect(sizes).toEqual([...sizes].sort((x: number, y: number) => y - x));
+    expect(out.topChanges.map((n: any) => n.node)).toContain("batch-prod");
+    expect(out.changedCount).toBe(rec.byNode.filter((n: any) => n.change !== "same" || n.diff !== 0).length);
+    expect(out.changedCount).toBeGreaterThan(rec.byNode.filter((n: any) => n.change !== "same").length);
+    // the step that removes api-prod moves batch-prod and the line too, said in its moved
+    const step = out.steps.find((x: any) => x.node === "api-prod");
+    expect(step.moved.map((m: any) => m.node)).toEqual(expect.arrayContaining(["api-prod", "batch-prod"]));
+  });
+
+  it("a step's moved is kept whole, a neighbour that moved with the step's node too (the step's diff is not its node's)", async () => {
+    const data = fixture("cost-infra.plan-move.json");
+    const [first] = data.steps;
+    first.moved = [{ node: "db-prod", diff: 20 }, { node: "api-prod>db-prod", diff: 1.6 }];   // a line's transfer moved with it
+    answer = { stdout: JSON.stringify(data) };
+    const out = await call("infra_cost", { plan: "move" });
+    expect(out.steps[0]).toMatchObject({ node: "db-prod", diff: first.diff, movedCount: 2,
+      moved: [{ node: "db-prod", diff: 20 }, { node: "api-prod>db-prod", diff: 1.6 }] });
+    data.steps[0].moved = Array.from({ length: 30 }, (_, i) => ({ node: `n${i}`, diff: 30 - i }));
+    answer = { stdout: JSON.stringify(data) };
+    const many = await call("infra_cost", { plan: "move" });
+    expect(many.steps[0].moved).toHaveLength(20);
+    expect(many.steps[0].movedCount).toBe(30);
+  });
+
+  it("account is a switch: --account, and the account's old / new / difference", async () => {
+    answer = { stdout: raw("cost-infra.plan-move-account.json") };
+    const out = await call("infra_cost", { plan: "move", account: true, scenario: "sale" });
+    expect(calls[0].args).toEqual(["cost", "infra", projectDir, "--json", "--migration", "move", "--account", "--scenario", "sale"]);
+    expect(out.account).toEqual(fixture("cost-infra.plan-move-account.json").account);
+  });
+
+  it.each([["bad", "bad_plan"], ["none", "no_plan"]])("a %s plan is refused, priced nothing, the reason and problems kept", async (file, reason) => {
+    answer = { code: 2, stdout: raw(`cost-infra.plan-${file}.json`) };
+    const rec = fixture(`cost-infra.plan-${file}.json`);
+    const out = await call("infra_cost", { plan: "x" });
+    expect(out).toMatchObject({ ok: false, exit: 2, reason, message: rec.message });
+    expect(out.problems.byCode).toEqual(Object.fromEntries(rec.problems.map((p: any) => [p.code, 1])));
+    expect(out.usd).toBeUndefined();
+  });
+
+  it.each(["migration", "scenario", "old", "new", "diff", "byNode", "byProvider", "steps", "account",
+    "dir", "scenarios", "problems", "prices", "new.noPrice", "new.noRule", "new.loadUndefined", "diff.usd", "unpricedChanged",
+    "old.noPrice", "old.noRule", "old.loadUndefined", "byNode.0.unpriced", "steps.0.moved", "steps.0.moved.0.node", "steps.0.moved.0.diff"])(
+    "names %s when the plan's answer lacks it", async (key) => {
+      answer = { stdout: without("cost-infra.plan-move.json", key) };
+      expect(await harness.call("infra_cost", { project_dir: projectDir, plan: "move" }))
+        .toMatch(new RegExp(`^Error: cost infra[^:]*: the JSON has no "${key.split(".").pop()}"`));
+    });
+
+  it("refuses date, by and account where they do not apply, without running the CLI", async () => {
+    for (const params of [{ plan: "move", date: "2026-11-03" }, { plan: "move", by: "node" }, { account: true }]) {
+      expect(await harness.call("infra_cost", { project_dir: projectDir, ...params })).toMatch(/^Error: /);
+    }
+    expect(calls).toHaveLength(0);
+  });
+});