@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/policy.test.ts

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+import {
+  approvalKind,
+  decide,
+  review,
+  type PolicyFacts,
+} from "../backend/policy.js";
+
+const head = "a".repeat(40);
+const target = "b".repeat(40);
+function facts(): PolicyFacts {
+  return {
+    actor: { name: "Levi", kind: "human" },
+    change: { state: "open", head, target, openedBy: "morel", conflict: null },
+    head,
+    approvals: [],
+    checks: [],
+    headAuthors: ["morel"],
+    isMaintainer: true,
+    mayPush: true,
+    sourceOwner: "morel",
+    soleMember: false,
+  };
+}
+
+describe("Change policy from host identity and pinned review facts", () => {
+  it("lets a person maintainer merge an Agent's work with an implicit approval", () => {
+    expect(decide("merge", facts())).toEqual({ allowed: true });
+    expect(review(facts())).toEqual({
+      status: "ready",
+      decision: { allowed: true },
+    });
+  });
+  it("requires another eligible approval when the maintainer wrote the work", () => {
+    const own: PolicyFacts = { ...facts(), headAuthors: ["Levi"] };
+    expect(decide("merge", own)).toEqual({
+      allowed: false,
+      reason: "needs-approval",
+    });
+    expect(
+      decide("merge", {
+        ...own,
+        approvals: [{ actor: "Ada", head, kind: "human" }],
+      }),
+    ).toEqual({ allowed: true });
+  });
+  it("does not count approvals or checks from a previous head", () => {
+    const old: PolicyFacts = {
+      ...facts(),
+      headAuthors: ["Levi"],
+      approvals: [{ actor: "Ada", head: target, kind: "human" }],
+      checks: [{ head: target, status: "failed" }],
+    };
+    expect(decide("merge", old)).toEqual({
+      allowed: false,
+      reason: "needs-approval",
+    });
+  });
+  it.each(["queued", "running"] as const)(
+    "shows %s checks as waiting",
+    (status) => {
+      expect(
+        decide("merge", { ...facts(), checks: [{ head, status }] }),
+      ).toEqual({ allowed: false, reason: "checks-running" });
+    },
+  );
+  it("blocks failed checks even with an eligible approver", () => {
+    expect(
+      decide("merge", { ...facts(), checks: [{ head, status: "failed" }] }),
+    ).toEqual({ allowed: false, reason: "checks-failed" });
+  });
+  it("refuses the caller's stale head and a second merge while leased", () => {
+    expect(decide("merge", { ...facts(), head: target })).toEqual({
+      allowed: false,
+      reason: "moved",
+    });
+    expect(
+      decide("merge", {
+        ...facts(),
+        change: { ...facts().change, state: "merging" },
+      }),
+    ).toEqual({ allowed: false, reason: "merging" });
+  });
+  it("uses conflicts only for the current source and target pair", () => {
+    const conflict = { head, target, paths: ["food.txt"] };
+    expect(
+      decide("merge", { ...facts(), change: { ...facts().change, conflict } }),
+    ).toEqual({ allowed: false, reason: "conflict" });
+    expect(
+      decide("merge", {
+        ...facts(),
+        change: {
+          ...facts().change,
+          conflict: { ...conflict, target: "c".repeat(40) },
+        },
+      }),
+    ).toEqual({ allowed: true });
+  });
+  it("does not let Agents approve or merge", () => {
+    const agent: PolicyFacts = {
+      ...facts(),
+      actor: { name: "morel", kind: "agent" },
+      isMaintainer: false,
+    };
+    expect(decide("merge", agent)).toEqual({
+      allowed: false,
+      reason: "agents-cannot-merge",
+    });
+    expect(decide("approve", agent).allowed).toBe(false);
+  });
+  it("refuses approval by the opener or an author", () => {
+    expect(
+      decide("approve", {
+        ...facts(),
+        actor: { name: "morel", kind: "human" },
+      }),
+    ).toEqual({ allowed: false, reason: "self-approval" });
+    expect(decide("approve", { ...facts(), headAuthors: ["Levi"] })).toEqual({
+      allowed: false,
+      reason: "self-approval",
+    });
+  });
+  it("permits opening only for a source writer", () => {
+    expect(decide("open", { ...facts(), mayPush: false }).allowed).toBe(false);
+    expect(decide("open", facts())).toEqual({ allowed: true });
+  });
+  it.each(["merged", "closed"] as const)(
+    "preserves %s lifecycle status",
+    (state) => {
+      expect(
+        review({ ...facts(), change: { ...facts().change, state } }).status,
+      ).toBe(state);
+      expect(
+        decide("merge", { ...facts(), change: { ...facts().change, state } })
+          .allowed,
+      ).toBe(false);
+    },
+  );
+  it("lets only a host-attested sole member approve and merge their own work", () => {
+    const own: PolicyFacts = { ...facts(), headAuthors: ["Levi"] };
+    expect(decide("approve", own)).toEqual({
+      allowed: false,
+      reason: "self-approval",
+    });
+    const alone: PolicyFacts = { ...own, soleMember: true };
+    expect(decide("approve", alone)).toEqual({ allowed: true });
+    expect(approvalKind(alone)).toBe("self");
+    expect(decide("merge", alone)).toEqual({ allowed: true });
+    expect(approvalKind({ ...facts(), soleMember: true })).toBe("human");
+    // A stored self-approval never stands in for another reviewer.
+    expect(
+      decide("merge", {
+        ...own,
+        actor: { name: "Ada", kind: "human" },
+        headAuthors: ["Levi", "Ada"],
+        approvals: [{ actor: "Levi", head, kind: "self" }],
+      }),
+    ).toEqual({ allowed: false, reason: "needs-approval" });
+  });
+  it("never lets an Agent self-approve, even with a sole-member fact", () => {
+    const agent: PolicyFacts = {
+      ...facts(),
+      actor: { name: "morel", kind: "agent" },
+      isMaintainer: false,
+      soleMember: true,
+    };
+    expect(decide("approve", agent)).toEqual({
+      allowed: false,
+      reason: "agents-cannot-approve",
+    });
+  });
+});