@intentius/chant 0.45.0 → 0.49.0

package/src/cli/handlers/lifecycle.test.ts

@@ -53,7 +53,7 @@ vi.mock("../../config", async () => {
   };
 });
 
-const { runLifecycleDiff, runLifecyclePlan, runLifecycleSnapshot, runLifecycleShow, runLifecycleLog, runLifecycleUnknown } = await import("./lifecycle");
+const { runLifecycleDiff, runLifecyclePlan, runLifecycleSnapshot, runLifecycleShow, runLifecycleLog, runLifecycleTeardown, runLifecycleUnknown } = await import("./lifecycle");
 
 function makeArgs(overrides: Partial<ParsedArgs>): ParsedArgs {
   return {
@@ -821,6 +821,120 @@ describe("runLifecyclePlan", () => {
     expect(byName["sg-0abc123"].name).toBe("sg-0abc123");
   });
 
+  // #1832 — effect receipts are declared, diffed, and observed like any
+  // resource, but observe-only to the generic apply path: the plan compares
+  // live value to resolved expectation and proposes the fire, never a create.
+  describe("effect receipts (#1832)", () => {
+    const receiptEntity = (lexicon: string) => ({
+      lexicon,
+      entityType: lexicon === "chant" ? "Chant::EffectReceipt" : `${lexicon}::Receipt`,
+      name: "dbMigrated",
+      effect: "db-migrate",
+      flavor: "existence" as const,
+      inputs: {},
+      [Symbol.for("chant.declarable")]: true,
+      [Symbol.for("chant.effect-receipt")]: true,
+    });
+
+    const buildWithReceipt = (lexicon: string): BuildResult => {
+      const base = makeBuildResult({ aws: ["bucket"] });
+      base.entities.set("dbMigrated", receiptEntity(lexicon) as unknown as Parameters<typeof base.entities.set>[1]);
+      if (lexicon !== "aws") (base.manifest.lexicons as string[]).push(lexicon);
+      return base;
+    };
+
+    test("an absent receipt is an effect row, never a create", async () => {
+      buildMock.mockResolvedValue(buildWithReceipt("aws"));
+      const plugins: LexiconPlugin[] = [
+        createMockPlugin({
+          name: "aws",
+          emulator: awsEmulatorStub,
+          describeResources: async () => ({
+            observation: "v1" as const,
+            resources: { bucket: meta() },
+            // dbMigrated neither returned nor unobserved: confirmed absent.
+          }),
+        }),
+      ];
+      const exit = await runLifecyclePlan({
+        args: makeArgs({ path: "plan", extraPositional: "prod", json: true }),
+        plugins,
+        serializers: plugins.map((p) => p.serializer),
+      });
+      expect(exit).toBe(0);
+      const plan = JSON.parse(stdoutBuf.join("\n"));
+      const row = plan.entries.find((e: { name: string }) => e.name === "dbMigrated");
+      expect(row).toMatchObject({ action: "effect", effect: "db-migrate", effectReason: "receipt-absent", lexicon: "aws" });
+      expect(plan.entries.filter((e: { name: string; action: string }) => e.name === "dbMigrated")).toHaveLength(1);
+    });
+
+    test("a live receipt carrying the existence marker is a clean noop, and the render says nothing fires", async () => {
+      buildMock.mockResolvedValue(buildWithReceipt("aws"));
+      const plugins: LexiconPlugin[] = [
+        createMockPlugin({
+          name: "aws",
+          emulator: awsEmulatorStub,
+          describeResources: async () => ({
+            observation: "v1" as const,
+            resources: {
+              bucket: meta(),
+              dbMigrated: meta({ type: "aws::Receipt", attributes: { value: "chant.effect-receipt:exists" } }),
+            },
+          }),
+        }),
+      ];
+      const exit = await runLifecyclePlan({
+        args: makeArgs({ path: "plan", extraPositional: "prod" }),
+        plugins,
+        serializers: plugins.map((p) => p.serializer),
+      });
+      expect(exit).toBe(0);
+      expect(stdoutBuf.join("\n")).toContain("0 effect");
+      expect(stdoutBuf.join("\n")).not.toContain("effect will fire");
+    });
+
+    test("a stale receipt renders effect will fire", async () => {
+      buildMock.mockResolvedValue(buildWithReceipt("aws"));
+      const plugins: LexiconPlugin[] = [
+        createMockPlugin({
+          name: "aws",
+          emulator: awsEmulatorStub,
+          describeResources: async () => ({
+            observation: "v1" as const,
+            resources: {
+              bucket: meta(),
+              dbMigrated: meta({ type: "aws::Receipt", attributes: { value: "something-else" } }),
+            },
+          }),
+        }),
+      ];
+      const exit = await runLifecyclePlan({
+        args: makeArgs({ path: "plan", extraPositional: "prod" }),
+        plugins,
+        serializers: plugins.map((p) => p.serializer),
+      });
+      expect(exit).toBe(0);
+      expect(stdoutBuf.join("\n")).toContain("effect will fire: db-migrate");
+    });
+
+    test("a receipt no loaded lexicon observes is unobserved, loudly", async () => {
+      buildMock.mockResolvedValue(buildWithReceipt("chant"));
+      const plugins: LexiconPlugin[] = [
+        createMockPlugin({ name: "aws", emulator: awsEmulatorStub, describeResources: staticDescribeResources({ bucket: meta() }) }),
+      ];
+      const exit = await runLifecyclePlan({
+        args: makeArgs({ path: "plan", extraPositional: "prod", json: true }),
+        plugins,
+        serializers: plugins.map((p) => p.serializer),
+      });
+      expect(exit).toBe(0);
+      const plan = JSON.parse(stdoutBuf.join("\n"));
+      const row = plan.entries.find((e: { name: string }) => e.name === "dbMigrated");
+      expect(row).toMatchObject({ action: "unobserved", unobservedReason: "unsupported-kind" });
+      expect(stderrBuf.join("\n")).toContain("could not be observed");
+    });
+  });
+
   // #1166 — plan is always a live read (no `--live` flag of its own), so a
   // declared environment endpoint applies here exactly as it does for
   // `chant graph --live` / `chant lifecycle diff --live`.
@@ -1220,3 +1334,233 @@ describe("runLifecycleUnknown", () => {
     expect(stderr).toContain("log");
   });
 });
+
+describe("runLifecycleTeardown (#1222 — plan only)", () => {
+  let stdoutBuf: string[];
+  let stderrBuf: string[];
+
+  beforeEach(() => {
+    stdoutBuf = [];
+    stderrBuf = [];
+    vi.spyOn(console, "log").mockImplementation((s: string) => { stdoutBuf.push(s); });
+    vi.spyOn(console, "error").mockImplementation((s: string) => { stderrBuf.push(s); });
+    loadChantConfigMock.mockReset();
+    loadChantConfigMock.mockResolvedValue({
+      config: { environments: ["dev", "prod"], ownership: { stack: "shop", env: "dev" } },
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const run = (overrides: Partial<ParsedArgs>, plugins: LexiconPlugin[]) =>
+    runLifecycleTeardown({
+      args: makeArgs({ command: "lifecycle", path: "teardown", ...overrides }),
+      plugins,
+      serializers: [],
+    });
+
+  test("requires an environment", async () => {
+    expect(await run({}, [])).toBe(1);
+    expect(stderrBuf.join("\n")).toContain("Environment is required");
+  });
+
+  test("exits nonzero on an environment the project does not declare", async () => {
+    expect(await run({ extraPositional: "staging" }, [])).toBe(1);
+    const stderr = stderrBuf.join("\n");
+    expect(stderr).toContain('Unknown environment "staging"');
+    expect(stderr).toContain("dev, prod");
+  });
+
+  test("--yes executes the planned set and prints per-candidate outcomes", async () => {
+    const executeTeardown = vi.fn(async () => ({
+      outcomes: [{ name: "web", outcome: "deleted" as const }],
+    }));
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "dev" } }],
+      }),
+      executeTeardown,
+    });
+    expect(await run({ extraPositional: "dev", yes: true }, [plugin])).toBe(0);
+    expect(executeTeardown).toHaveBeenCalledWith({
+      environment: "dev",
+      marker: { stack: "shop", env: "dev" },
+      candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "dev" } }],
+    });
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("Outcomes:");
+    expect(out).toContain("deleted");
+    expect(out).toContain("1 deleted, 0 failed, 0 not prunable, 0 retained, 0 skipped");
+    expect(out).not.toContain("plan only");
+  });
+
+  test("--yes exits nonzero when a candidate stays failed after the retry pass", async () => {
+    const executeTeardown = vi.fn(async () => ({
+      outcomes: [{ name: "web", outcome: "failed" as const, detail: "conflict" }],
+    }));
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "dev" } }],
+      }),
+      executeTeardown,
+    });
+    expect(await run({ extraPositional: "dev", yes: true }, [plugin])).toBe(1);
+    expect(executeTeardown).toHaveBeenCalledTimes(2); // pass + bounded retry
+    expect(stderrBuf.join("\n")).toContain("failed to delete after the retry pass");
+  });
+
+  test("--yes with a lexicon that only enumerates reports skipped, not deleted", async () => {
+    const plugin = createMockPlugin({
+      name: "gcp",
+      teardownOwned: async () => ({
+        candidates: [{ name: "bucket", type: "GCP::Storage::Bucket", marker: { stack: "shop", env: "dev" } }],
+      }),
+    });
+    expect(await run({ extraPositional: "dev", yes: true }, [plugin])).toBe(0);
+    expect(stdoutBuf.join("\n")).toContain("skipped");
+    expect(stderrBuf.join("\n")).toContain("no teardown execution in these lexicons yet");
+  });
+
+  test("--yes on a production-like environment demands --confirm-prod when not interactive", async () => {
+    const executeTeardown = vi.fn();
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({ candidates: [] }),
+      executeTeardown,
+    });
+    expect(await run({ extraPositional: "prod", yes: true }, [plugin])).toBe(1);
+    expect(stderrBuf.join("\n")).toContain("--confirm-prod");
+    expect(executeTeardown).not.toHaveBeenCalled();
+  });
+
+  test("--yes --confirm-prod tears a production-like environment down non-interactively", async () => {
+    const executeTeardown = vi.fn(async () => ({
+      outcomes: [{ name: "web", outcome: "deleted" as const }],
+    }));
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "prod" } }],
+      }),
+      executeTeardown,
+    });
+    expect(await run({ extraPositional: "prod", yes: true, confirmProd: true }, [plugin])).toBe(0);
+    expect(executeTeardown).toHaveBeenCalledTimes(1);
+  });
+
+  test("the prod guard never fires without --yes — planning production is safe", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({ candidates: [] }),
+    });
+    expect(await run({ extraPositional: "prod" }, [plugin])).toBe(0);
+    expect(stderrBuf.join("\n")).not.toContain("--confirm-prod");
+  });
+
+  test("--yes --json emits the execution report", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "dev" } }],
+      }),
+      executeTeardown: async () => ({ outcomes: [{ name: "web", outcome: "deleted" as const }] }),
+    });
+    expect(await run({ extraPositional: "dev", yes: true, json: true }, [plugin])).toBe(0);
+    const parsed = JSON.parse(stdoutBuf.join("\n"));
+    expect(parsed.outcomes).toEqual([
+      {
+        lexicon: "k8s",
+        name: "web",
+        type: "K8s::Apps::Deployment",
+        marker: { stack: "shop", env: "dev" },
+        outcome: "deleted",
+      },
+    ]);
+  });
+
+  test("refuses when the project declares no ownership.stack", async () => {
+    loadChantConfigMock.mockResolvedValue({ config: { environments: ["dev"] } });
+    expect(await run({ extraPositional: "dev" }, [])).toBe(1);
+    expect(stderrBuf.join("\n")).toContain("no ownership.stack");
+  });
+
+  test("prints the would-delete set with resource, type, and marker identity", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [
+          { name: "web", type: "K8s::Apps::Deployment", physicalId: "web-1", marker: { stack: "shop", env: "dev" } },
+        ],
+      }),
+    });
+    expect(await run({ extraPositional: "dev" }, [plugin])).toBe(0);
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("Teardown plan");
+    expect(out).toContain("plan only");
+    expect(out).toContain("web");
+    expect(out).toContain("K8s::Apps::Deployment");
+    expect(out).toContain("shop/dev");
+    expect(stderrBuf.join("\n")).toContain("re-run with --yes to execute");
+  });
+
+  test("never selects foreign-stack or foreign-env resources on the fallback path", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      describeResources: staticObservation({
+        mine: { type: "K8s::Apps::Deployment", status: "READY", marker: { stack: "shop", env: "dev" } },
+        theirs: { type: "K8s::Apps::Deployment", status: "READY", marker: { stack: "blog", env: "dev" } },
+        prodTwin: { type: "K8s::Apps::Deployment", status: "READY", marker: { stack: "shop", env: "prod" } },
+        unmarked: { type: "K8s::Apps::Deployment", status: "READY" },
+      }),
+    });
+    expect(await run({ extraPositional: "dev" }, [plugin])).toBe(0);
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("mine");
+    expect(out).not.toContain("theirs");
+    expect(out).not.toContain("prodTwin");
+    expect(out).not.toContain("unmarked");
+  });
+
+  test("an empty would-delete set is loud, not silent", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({ candidates: [] }),
+    });
+    expect(await run({ extraPositional: "dev" }, [plugin])).toBe(0);
+    expect(stderrBuf.join("\n")).toContain("nothing would be deleted");
+  });
+
+  test("holes are surfaced loudly (#1089)", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [],
+        holes: [{ name: "crds", type: "K8s::CRD", reason: "unsupported-kind" as const, detail: "no reader" }],
+      }),
+    });
+    expect(await run({ extraPositional: "dev" }, [plugin])).toBe(0);
+    expect(stderrBuf.join("\n")).toContain("incomplete, not clean");
+    const out = stdoutBuf.join("\n");
+    expect(out).toContain("HOLES");
+    expect(out).toContain("crds");
+    expect(out).toContain("unsupported-kind");
+  });
+
+  test("--json emits the plan as JSON", async () => {
+    const plugin = createMockPlugin({
+      name: "k8s",
+      teardownOwned: async () => ({
+        candidates: [{ name: "web", type: "K8s::Apps::Deployment", marker: { stack: "shop", env: "dev" } }],
+      }),
+    });
+    expect(await run({ extraPositional: "dev", json: true }, [plugin])).toBe(0);
+    const parsed = JSON.parse(stdoutBuf.join("\n"));
+    expect(parsed.environment).toBe("dev");
+    expect(parsed.stack).toBe("shop");
+    expect(parsed.entries).toHaveLength(1);
+  });
+});