cedar-mcp-server 1.0.0

package/test/tools/check-change.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+import { handleCheckChange } from "../../src/tools/check-change.js";
+
+describe("cedar_check_policy_change", () => {
+  it("4.1 — principal change requires recreate", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(principal in MyApp::Role::"customer_account_access", action == MyApp::Action::"POST", resource);`,
+      new_policy: `permit(principal in MyApp::Role::"customer_management_access", action == MyApp::Action::"POST", resource);`,
+    });
+
+    expect(result.can_update_in_place).toBe(false);
+    const change = result.changes.find((c) => c.field === "principal");
+    expect(change).toBeDefined();
+    expect(change!.in_place_allowed).toBe(false);
+  });
+
+  it("4.2 — effect change (permit → forbid) requires recreate", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(principal in MyApp::Role::"temp_access", action, resource);`,
+      new_policy: `forbid(principal in MyApp::Role::"temp_access", action, resource);`,
+    });
+
+    expect(result.can_update_in_place).toBe(false);
+    const change = result.changes.find((c) => c.field === "effect");
+    expect(change).toBeDefined();
+    expect(change!.in_place_allowed).toBe(false);
+  });
+
+  it("4.3 — resource change requires recreate", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(principal, action == MyApp::Action::"READ", resource == MyApp::Document::"doc-A");`,
+      new_policy: `permit(principal, action == MyApp::Action::"READ", resource == MyApp::Document::"doc-B");`,
+    });
+
+    expect(result.can_update_in_place).toBe(false);
+    const change = result.changes.find((c) => c.field === "resource");
+    expect(change).toBeDefined();
+    expect(change!.in_place_allowed).toBe(false);
+  });
+
+  it("4.4 — action change is in-place OK", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(principal in MyApp::Role::"editor", action == MyApp::Action::"READ", resource);`,
+      new_policy: `permit(principal in MyApp::Role::"editor", action in [MyApp::Action::"READ", MyApp::Action::"WRITE"], resource);`,
+    });
+
+    expect(result.can_update_in_place).toBe(true);
+    const change = result.changes.find((c) => c.field === "action");
+    expect(change).toBeDefined();
+    expect(change!.in_place_allowed).toBe(true);
+  });
+
+  it("4.5 — condition change is in-place OK", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(principal, action, resource) when { principal.name == "user_a" && resource.status == "active" };`,
+      new_policy: `permit(principal, action, resource) when { principal.name == "user_a" && ["active", "pending"].contains(resource.status) };`,
+    });
+
+    expect(result.can_update_in_place).toBe(true);
+    const change = result.changes.find((c) => c.field === "conditions");
+    expect(change).toBeDefined();
+    expect(change!.in_place_allowed).toBe(true);
+  });
+
+  it("4.6 — mixed changes: principal blocks in-place even though action + condition are OK", async () => {
+    const result = await handleCheckChange({
+      old_policy: `permit(
+        principal in MyApp::Role::"old_role",
+        action == MyApp::Action::"READ",
+        resource
+      ) when { resource.status == "active" };`,
+      new_policy: `permit(
+        principal in MyApp::Role::"new_role",
+        action in [MyApp::Action::"READ", MyApp::Action::"WRITE"],
+        resource
+      ) when { resource.status == "active" || resource.status == "pending" };`,
+    });
+
+    expect(result.can_update_in_place).toBe(false);
+    expect(result.changes.find((c) => c.field === "principal")?.in_place_allowed).toBe(false);
+    expect(result.changes.find((c) => c.field === "action")?.in_place_allowed).toBe(true);
+    expect(result.changes.find((c) => c.field === "conditions")?.in_place_allowed).toBe(true);
+  });
+
+  it("returns structured error for invalid Cedar input instead of throwing", async () => {
+    const result = await handleCheckChange({
+      old_policy: "this is not cedar",
+      new_policy: `permit(principal, action, resource);`,
+    });
+
+    expect(result.error).toBeDefined();
+    expect(result.error).toContain("Failed to parse old_policy");
+    expect(result.can_update_in_place).toBe(false);
+    expect(result.changes).toHaveLength(0);
+  });
+
+  it("4.7 — identical policies: no changes, can update in place", async () => {
+    const policy = `permit(principal in MyApp::Role::"viewer", action == MyApp::Action::"READ", resource);`;
+    const result = await handleCheckChange({ old_policy: policy, new_policy: policy });
+
+    expect(result.can_update_in_place).toBe(true);
+    expect(result.changes).toHaveLength(0);
+  });
+});

package/test/tools/cross-fixture.test.ts

@@ -0,0 +1,170 @@
+// Cross-fixture smoke tests: exercise the tool surface against Dataset 2
+// (Insurance ABAC) to confirm tools aren't locked to Dataset 1 assumptions.
+import { describe, it, expect } from "vitest";
+import { handleAuthorize } from "../../src/tools/authorize.js";
+import { handleValidate } from "../../src/tools/validate.js";
+import { handleValidateSchema } from "../../src/tools/validate-schema.js";
+import { handleValidateEntities } from "../../src/tools/validate-entities.js";
+import { handleDiffSchema } from "../../src/tools/diff-schema.js";
+import {
+  POLICIES,
+  SCHEMA_JSON,
+  ENTITIES,
+} from "../fixtures/multitenant.js";
+import { SCHEMA_JSON as DOCMGMT_SCHEMA } from "../fixtures/docmgmt.js";
+
+const SCHEMA_STR = JSON.stringify(SCHEMA_JSON);
+
+// ---------------------------------------------------------------------------
+// cedar_validate_schema — Dataset 2 schema is well-formed
+// ---------------------------------------------------------------------------
+describe("cedar_validate_schema — Insurance (Dataset 2)", () => {
+  it("CF-VS1: Insurance JSON schema is valid", async () => {
+    const result = await handleValidateSchema({ schema: SCHEMA_STR });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.namespaces).toContain("Insurance");
+  });
+
+  it("CF-VS2: reports correct entity type and action counts", async () => {
+    const result = await handleValidateSchema({ schema: SCHEMA_STR });
+    // Identity, Role, Policy = 3 entity types; CREATE, READ, UPDATE = 3 actions
+    expect(result.entity_type_count).toBe(3);
+    expect(result.action_count).toBe(3);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cedar_validate — policies validate cleanly against Dataset 2 schema
+// ---------------------------------------------------------------------------
+describe("cedar_validate — Insurance policies (Dataset 2)", () => {
+  it("CF-V1: all Insurance policies are valid against the schema", async () => {
+    const result = await handleValidate({ policies: POLICIES, schema: SCHEMA_STR });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("CF-V2: policy referencing a nonexistent attribute is invalid", async () => {
+    const bad = `permit(principal, action, resource) when { resource.nonexistent == "x" };`;
+    const result = await handleValidate({ policies: bad, schema: SCHEMA_STR });
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cedar_validate_entities — Dataset 2 entity set is valid
+// ---------------------------------------------------------------------------
+describe("cedar_validate_entities — Insurance entities (Dataset 2)", () => {
+  it("CF-VE1: full Insurance entity set is valid against its schema", async () => {
+    const result = await handleValidateEntities({
+      entities: JSON.stringify(ENTITIES),
+      schema: SCHEMA_STR,
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.entity_count).toBe(ENTITIES.length);
+  });
+
+  it("CF-VE2: optional insurer attribute absent on POL-004 does not cause a validation error", async () => {
+    // POL-004 intentionally has no `insurer` field — must still be valid (required: false)
+    const pol004 = ENTITIES.filter((e) => e.uid.id === "POL-004");
+    const result = await handleValidateEntities({
+      entities: JSON.stringify(pol004),
+      schema: SCHEMA_STR,
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cedar_authorize — ABAC decisions against Dataset 2
+// ---------------------------------------------------------------------------
+describe("cedar_authorize — Insurance ABAC (Dataset 2)", () => {
+  it("CF-A1: tenant-a is allowed READ on POL-001 (matching vertical + business_unit)", async () => {
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"tenant-a"',
+      action: 'Insurance::Action::"READ"',
+      resource: 'Insurance::Policy::"POL-001"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Allow");
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("CF-A2: tenant-a is denied READ on POL-002 (wrong business_unit)", async () => {
+    // POL-002 vertical=commercial_landlord — not in tenant-a permit list
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"tenant-a"',
+      action: 'Insurance::Action::"READ"',
+      resource: 'Insurance::Policy::"POL-002"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Deny");
+  });
+
+  it("CF-A3: tenant-b READ denied on POL-004 — resource has no insurer attr", async () => {
+    // POL-004 has no insurer; `resource has insurer` is false → policy doesn't apply
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"tenant-b"',
+      action: 'Insurance::Action::"READ"',
+      resource: 'Insurance::Policy::"POL-004"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Deny");
+  });
+
+  it("CF-A4: unknown-client READ denied — default deny, no policy matches", async () => {
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"unknown-client"',
+      action: 'Insurance::Action::"READ"',
+      resource: 'Insurance::Policy::"POL-001"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Deny");
+    expect(result.determining_policies).toHaveLength(0);
+  });
+
+  it("CF-A5: tenant-d CREATE allowed", async () => {
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"tenant-d"',
+      action: 'Insurance::Action::"CREATE"',
+      resource: 'Insurance::Policy::"POL-001"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Allow");
+  });
+
+  it("CF-A6: tenant-d UPDATE denied — not in permitted action list", async () => {
+    const result = await handleAuthorize({
+      policies: POLICIES,
+      principal: 'Insurance::Identity::"tenant-d"',
+      action: 'Insurance::Action::"UPDATE"',
+      resource: 'Insurance::Policy::"POL-001"',
+      entities: JSON.stringify(ENTITIES),
+    });
+    expect(result.decision).toBe("Deny");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// cedar_diff_schema — cross-dataset diff (Dataset 1 vs Dataset 2)
+// ---------------------------------------------------------------------------
+describe("cedar_diff_schema — DocMgmt vs Insurance (cross-fixture)", () => {
+  it("CF-DS1: diffing two distinct namespaces reports both namespaces as added/removed", async () => {
+    const result = await handleDiffSchema({
+      blue: JSON.stringify(DOCMGMT_SCHEMA),
+      green: SCHEMA_STR,
+    });
+    // DocMgmt was in blue → removed; Insurance is in green → added
+    expect(result.namespaces_removed).toContain("DocMgmt");
+    expect(result.namespaces_added).toContain("Insurance");
+    expect(result.risk_level).toBe("breaking");
+  });
+});

package/test/tools/diff-schema.test.ts

@@ -0,0 +1,355 @@
+import { describe, it, expect } from "vitest";
+import { handleDiffSchema } from "../../src/tools/diff-schema.js";
+
+// Canonical Dataset 1 schema for diff tests. Keep small & focused so each
+// test case is self-contained and the diff under test is obvious from inspection.
+const BASE_SCHEMA = `
+namespace App {
+  entity User in [Role] = { name: String, email: String };
+  entity Role;
+  entity Document in [Folder] = { owner: String, classification: String };
+  entity Folder;
+  action READ, WRITE appliesTo {
+    principal: [User],
+    resource: [Document]
+  };
+}
+`.trim();
+
+describe("cedar_diff_schema — structural", () => {
+  it("DS1: identical schemas produce an empty diff with risk_level safe", async () => {
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green: BASE_SCHEMA });
+
+    expect(result.risk_level).toBe("safe");
+    expect(result.entity_types.added).toHaveLength(0);
+    expect(result.entity_types.removed).toHaveLength(0);
+    expect(result.entity_types.modified).toHaveLength(0);
+    expect(result.actions.added).toHaveLength(0);
+    expect(result.actions.removed).toHaveLength(0);
+    expect(result.actions.modified).toHaveLength(0);
+    expect(result.summary).toMatch(/no schema changes/i);
+  });
+
+  it("DS2: entity type added in green → entity_types.added, risk safe", async () => {
+    const green = BASE_SCHEMA.replace(
+      "entity Folder;",
+      "entity Folder;\n  entity Tag = { label: String };"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    expect(result.entity_types.added).toContainEqual({ namespace: "App", name: "Tag" });
+    expect(result.risk_level).toBe("safe");
+  });
+
+  it("DS3: entity type removed in green → entity_types.removed, risk breaking", async () => {
+    const green = BASE_SCHEMA.replace("entity Folder;\n  ", "");
+    // Folder is referenced in 'entity Document in [Folder]' — also strip that
+    const greenClean = green.replace(" in [Folder]", "");
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green: greenClean });
+
+    expect(result.entity_types.removed).toContainEqual(
+      expect.objectContaining({ namespace: "App", name: "Folder", risk: "breaking" })
+    );
+    expect(result.risk_level).toBe("breaking");
+  });
+});
+
+describe("cedar_diff_schema — attribute changes", () => {
+  it("DS4a: optional attribute added → safe", async () => {
+    const green = BASE_SCHEMA.replace(
+      "{ name: String, email: String }",
+      "{ name: String, email: String, phone?: String }"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    const userMod = result.entity_types.modified.find((m) => m.name === "User");
+    expect(userMod).toBeDefined();
+    const phoneChange = userMod!.attribute_changes?.find((c) => c.attr === "phone");
+    expect(phoneChange).toBeDefined();
+    expect(phoneChange!.change).toBe("added");
+    expect(phoneChange!.risk).toBe("safe");
+  });
+
+  it("DS4b: required attribute added → breaking", async () => {
+    const green = BASE_SCHEMA.replace(
+      "{ name: String, email: String }",
+      "{ name: String, email: String, phone: String }"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    const userMod = result.entity_types.modified.find((m) => m.name === "User");
+    const phoneChange = userMod!.attribute_changes?.find((c) => c.attr === "phone");
+    expect(phoneChange!.change).toBe("added");
+    expect(phoneChange!.risk).toBe("breaking");
+    expect(result.risk_level).toBe("breaking");
+  });
+
+  it("DS5: attribute removed → breaking", async () => {
+    const green = BASE_SCHEMA.replace(
+      "{ name: String, email: String }",
+      "{ name: String }"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    const userMod = result.entity_types.modified.find((m) => m.name === "User");
+    const emailChange = userMod!.attribute_changes?.find((c) => c.attr === "email");
+    expect(emailChange!.change).toBe("removed");
+    expect(emailChange!.risk).toBe("breaking");
+  });
+
+  it("DS6: attribute type changed (String → Long) → breaking", async () => {
+    const green = BASE_SCHEMA.replace(
+      "{ name: String, email: String }",
+      "{ name: Long, email: String }"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    const userMod = result.entity_types.modified.find((m) => m.name === "User");
+    const nameChange = userMod!.attribute_changes?.find((c) => c.attr === "name");
+    expect(nameChange!.change).toBe("type_changed");
+    expect(nameChange!.old_type).toBe("String");
+    expect(nameChange!.new_type).toBe("Long");
+    expect(nameChange!.risk).toBe("breaking");
+  });
+});
+
+describe("cedar_diff_schema — action changes", () => {
+  it("DS7: action added → safe", async () => {
+    const green = BASE_SCHEMA.replace(
+      "action READ, WRITE appliesTo",
+      "action READ, WRITE, DELETE appliesTo"
+    );
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    expect(result.actions.added).toContainEqual({ namespace: "App", name: "DELETE" });
+    expect(result.risk_level).toBe("safe");
+  });
+
+  it("DS8: action removed → breaking", async () => {
+    const green = BASE_SCHEMA.replace("action READ, WRITE appliesTo", "action READ appliesTo");
+
+    const result = await handleDiffSchema({ blue: BASE_SCHEMA, green });
+
+    expect(result.actions.removed).toContainEqual(
+      expect.objectContaining({ namespace: "App", name: "WRITE", risk: "breaking" })
+    );
+    expect(result.risk_level).toBe("breaking");
+  });
+
+  it("DS9: action principal_types widened → review", async () => {
+    // Add a new principal type; action gains another principal type
+    const blue = `
+namespace App {
+  entity User;
+  entity Admin;
+  entity Document;
+  action READ appliesTo { principal: [User], resource: [Document] };
+}
+`.trim();
+    const green = `
+namespace App {
+  entity User;
+  entity Admin;
+  entity Document;
+  action READ appliesTo { principal: [User, Admin], resource: [Document] };
+}
+`.trim();
+
+    const result = await handleDiffSchema({ blue, green });
+
+    const readMod = result.actions.modified.find((m) => m.name === "READ");
+    expect(readMod).toBeDefined();
+    expect(readMod!.principal_types?.added).toEqual(["App::Admin"]);
+    expect(readMod!.principal_types?.risk).toBe("review");
+  });
+
+  it("DS10: action principal_types narrowed → breaking", async () => {
+    const blue = `
+namespace App {
+  entity User;
+  entity Admin;
+  entity Document;
+  action READ appliesTo { principal: [User, Admin], resource: [Document] };
+}
+`.trim();
+    const green = `
+namespace App {
+  entity User;
+  entity Admin;
+  entity Document;
+  action READ appliesTo { principal: [User], resource: [Document] };
+}
+`.trim();
+
+    const result = await handleDiffSchema({ blue, green });
+
+    const readMod = result.actions.modified.find((m) => m.name === "READ");
+    expect(readMod!.principal_types?.removed).toEqual(["App::Admin"]);
+    expect(readMod!.principal_types?.risk).toBe("breaking");
+  });
+});
+
+describe("cedar_diff_schema — input formats and errors", () => {
+  it("DS13: malformed blue schema returns error result, not crash", async () => {
+    const result = await handleDiffSchema({ blue: "not a schema", green: BASE_SCHEMA });
+
+    expect(result.error).toBeTruthy();
+  });
+
+  it("DS14: blue and green in different formats (JSON vs cedarschema) — diff still works", async () => {
+    const jsonForm = JSON.stringify({
+      App: {
+        entityTypes: {
+          User: { memberOfTypes: [], shape: { type: "Record", attributes: { name: { type: "String", required: true } } } },
+          Document: { memberOfTypes: [], shape: { type: "Record", attributes: {} } },
+        },
+        actions: {
+          READ: { appliesTo: { principalTypes: ["User"], resourceTypes: ["Document"] } },
+        },
+      },
+    });
+    const cedarForm = `
+namespace App {
+  entity User = { name: String };
+  entity Document;
+  action READ appliesTo { principal: [User], resource: [Document] };
+}
+`.trim();
+
+    const result = await handleDiffSchema({ blue: jsonForm, green: cedarForm });
+
+    // Same logical content — diff should be empty
+    expect(result.entity_types.added).toHaveLength(0);
+    expect(result.entity_types.removed).toHaveLength(0);
+    expect(result.entity_types.modified).toHaveLength(0);
+    expect(result.actions.added).toHaveLength(0);
+    expect(result.actions.removed).toHaveLength(0);
+  });
+});
+
+describe("cedar_diff_schema — falsification: diff predicts cedar_validate outcome", () => {
+  it("DSF: when diff says 'breaking' for an attribute removal, a policy referencing the attribute fails cedar_validate against green", async () => {
+    const { handleValidate } = await import("../../src/tools/validate.js");
+
+    const blue = `
+namespace App {
+  entity User = { name: String, email: String };
+  entity Doc;
+  action READ appliesTo { principal: [User], resource: [Doc] };
+}
+`.trim();
+    const green = `
+namespace App {
+  entity User = { name: String };
+  entity Doc;
+  action READ appliesTo { principal: [User], resource: [Doc] };
+}
+`.trim();
+    const policy = `permit (principal, action, resource) when { principal.email == "alice@x.y" };`;
+
+    // 1. Policy is valid against blue
+    const blueValidation = await handleValidate({ policies: policy, schema: blue });
+    expect(blueValidation.valid).toBe(true);
+
+    // 2. Diff classifies email removal as breaking
+    const diff = await handleDiffSchema({ blue, green });
+    const userMod = diff.entity_types.modified.find((m) => m.name === "User");
+    expect(userMod).toBeDefined();
+    const emailChange = userMod!.attribute_changes?.find((c) => c.attr === "email");
+    expect(emailChange!.change).toBe("removed");
+    expect(emailChange!.risk).toBe("breaking");
+
+    // 3. Policy is INVALID against green — falsification check passes
+    const greenValidation = await handleValidate({ policies: policy, schema: green });
+    expect(greenValidation.valid).toBe(false);
+  });
+});
+
+describe("cedar_diff_schema — namespace changes", () => {
+  it("DS15: namespace added → namespaces_added has it; all entities in new ns reported as added", async () => {
+    const green = `
+namespace App {
+  entity User;
+  entity Role;
+  entity Document in [Folder];
+  entity Folder;
+  action READ, WRITE appliesTo {
+    principal: [User],
+    resource: [Document]
+  };
+}
+
+namespace Audit {
+  entity Event = { kind: String };
+  action LOG appliesTo { principal: [App::User], resource: [Event] };
+}
+`.trim();
+    const blue = `
+namespace App {
+  entity User in [Role] = { name: String, email: String };
+  entity Role;
+  entity Document in [Folder] = { owner: String, classification: String };
+  entity Folder;
+  action READ, WRITE appliesTo {
+    principal: [User],
+    resource: [Document]
+  };
+}
+`.trim();
+    // Use a simpler blue without attrs so we just check namespace addition behavior
+    const simpleBlue = `
+namespace App {
+  entity User;
+  entity Role;
+  entity Document in [Folder];
+  entity Folder;
+  action READ, WRITE appliesTo {
+    principal: [User],
+    resource: [Document]
+  };
+}
+`.trim();
+
+    const result = await handleDiffSchema({ blue: simpleBlue, green });
+
+    expect(result.namespaces_added).toContain("Audit");
+    expect(result.entity_types.added).toContainEqual({ namespace: "Audit", name: "Event" });
+    expect(result.actions.added).toContainEqual({ namespace: "Audit", name: "LOG" });
+  });
+
+  it("DS16: namespace removed → namespaces_removed has it, all entities in removed ns reported as breaking removed", async () => {
+    const blue = `
+namespace App {
+  entity User;
+}
+
+namespace Audit {
+  entity Event = { kind: String };
+  action LOG appliesTo { principal: [App::User], resource: [Event] };
+}
+`.trim();
+    const green = `
+namespace App {
+  entity User;
+}
+`.trim();
+
+    const result = await handleDiffSchema({ blue, green });
+
+    expect(result.namespaces_removed).toContain("Audit");
+    expect(result.entity_types.removed).toContainEqual(
+      expect.objectContaining({ namespace: "Audit", name: "Event", risk: "breaking" })
+    );
+    expect(result.actions.removed).toContainEqual(
+      expect.objectContaining({ namespace: "Audit", name: "LOG", risk: "breaking" })
+    );
+    expect(result.risk_level).toBe("breaking");
+  });
+});