@company-semantics/contracts 9.0.0 → 9.2.0

package/src/execution/__tests__/lifecycle.test.ts

@@ -1,261 +1,263 @@
-import { describe, it, expect } from 'vitest'
-import type { ExecutionState } from '../status.js'
+import { describe, it, expect } from "vitest";
+import type { ExecutionState } from "../status.js";
 import {
   VALID_TRANSITIONS,
   TERMINAL_STATES,
   EFFECTIVE_TERMINAL_STATES,
   assertValidTransition,
-} from '../status.js'
-import { LIFECYCLE_DECISIONS, applyIntent } from '../lifecycle.js'
-import type { ExecutionErrorCode } from '../errors.js'
-import { parseExpiresAt, isConfirmationExpired } from '../expiry.js'
+} from "../status.js";
+import { LIFECYCLE_DECISIONS, applyIntent } from "../lifecycle.js";
+import type { ExecutionErrorCode } from "../errors.js";
+import { parseExpiresAt, isConfirmationExpired } from "../expiry.js";
 
 const ALL_STATES: ExecutionState[] = [
-  'pending_confirmation',
-  'blocked_pending_approval',
-  'ready',
-  'executing',
-  'completed',
-  'completed_with_rollbacks',
-  'failed_retryable',
-  'failed_exhausted',
-  'failed_terminal',
-  'failed_with_partial_execution',
-  'cancelled',
-  'expired',
-  'undone',
-]
+  "pending_confirmation",
+  "blocked_pending_approval",
+  "ready",
+  "executing",
+  "completed",
+  "completed_with_rollbacks",
+  "failed_retryable",
+  "failed_exhausted",
+  "failed_terminal",
+  "failed_with_partial_execution",
+  "cancelled",
+  "expired",
+  "undone",
+];
 
 // ---------------------------------------------------------------------------
 // 1. EXHAUSTIVE TRANSITION MATRIX
 // ---------------------------------------------------------------------------
-describe('exhaustive transition matrix', () => {
+describe("exhaustive transition matrix", () => {
   for (const from of ALL_STATES) {
     for (const to of ALL_STATES) {
-      const allowed = VALID_TRANSITIONS[from].includes(to)
-      it(`${from} -> ${to} should be ${allowed ? 'valid' : 'invalid'}`, () => {
+      const allowed = VALID_TRANSITIONS[from].includes(to);
+      it(`${from} -> ${to} should be ${allowed ? "valid" : "invalid"}`, () => {
         if (allowed) {
-          expect(() => assertValidTransition(from, to)).not.toThrow()
+          expect(() => assertValidTransition(from, to)).not.toThrow();
         } else {
           expect(() => assertValidTransition(from, to)).toThrow(
             `Invalid execution state transition: ${from} -> ${to}`,
-          )
+          );
         }
-      })
+      });
     }
   }
-})
+});
 
 // ---------------------------------------------------------------------------
 // 2. TERMINAL_STATES CONSISTENCY
 // ---------------------------------------------------------------------------
-describe('TERMINAL_STATES consistency', () => {
-  it('contains exactly the states with empty transition arrays', () => {
+describe("TERMINAL_STATES consistency", () => {
+  it("contains exactly the states with empty transition arrays", () => {
     const expectedTerminal = ALL_STATES.filter(
       (s) => VALID_TRANSITIONS[s].length === 0,
-    )
-    expect(expectedTerminal.length).toBeGreaterThan(0)
+    );
+    expect(expectedTerminal.length).toBeGreaterThan(0);
     for (const state of expectedTerminal) {
-      expect(TERMINAL_STATES.has(state)).toBe(true)
+      expect(TERMINAL_STATES.has(state)).toBe(true);
     }
-    expect(TERMINAL_STATES.size).toBe(expectedTerminal.length)
-  })
+    expect(TERMINAL_STATES.size).toBe(expectedTerminal.length);
+  });
 
-  it('does not contain states with non-empty transition arrays', () => {
+  it("does not contain states with non-empty transition arrays", () => {
     const nonTerminal = ALL_STATES.filter(
       (s) => VALID_TRANSITIONS[s].length > 0,
-    )
+    );
     for (const state of nonTerminal) {
-      expect(TERMINAL_STATES.has(state)).toBe(false)
+      expect(TERMINAL_STATES.has(state)).toBe(false);
     }
-  })
-})
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 3. EFFECTIVE_TERMINAL_STATES
 // ---------------------------------------------------------------------------
-describe('EFFECTIVE_TERMINAL_STATES', () => {
-  it('contains all TERMINAL_STATES', () => {
+describe("EFFECTIVE_TERMINAL_STATES", () => {
+  it("contains all TERMINAL_STATES", () => {
     for (const state of TERMINAL_STATES) {
-      expect(EFFECTIVE_TERMINAL_STATES.has(state)).toBe(true)
+      expect(EFFECTIVE_TERMINAL_STATES.has(state)).toBe(true);
     }
-  })
+  });
 
-  it('contains completed', () => {
-    expect(EFFECTIVE_TERMINAL_STATES.has('completed')).toBe(true)
-  })
+  it("contains completed", () => {
+    expect(EFFECTIVE_TERMINAL_STATES.has("completed")).toBe(true);
+  });
 
-  it('has size equal to TERMINAL_STATES + 1 (completed)', () => {
-    expect(EFFECTIVE_TERMINAL_STATES.size).toBe(TERMINAL_STATES.size + 1)
-  })
+  it("has size equal to TERMINAL_STATES + 1 (completed)", () => {
+    expect(EFFECTIVE_TERMINAL_STATES.size).toBe(TERMINAL_STATES.size + 1);
+  });
 
-  it('does not contain non-terminal, non-completed states', () => {
+  it("does not contain non-terminal, non-completed states", () => {
     const nonEffectiveTerminal = ALL_STATES.filter(
-      (s) => !TERMINAL_STATES.has(s) && s !== 'completed',
-    )
+      (s) => !TERMINAL_STATES.has(s) && s !== "completed",
+    );
     for (const state of nonEffectiveTerminal) {
-      expect(EFFECTIVE_TERMINAL_STATES.has(state)).toBe(false)
+      expect(EFFECTIVE_TERMINAL_STATES.has(state)).toBe(false);
     }
-  })
-})
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 4. DECISION TABLE KEY CONSISTENCY
 // ---------------------------------------------------------------------------
-describe('decision table key consistency', () => {
-  it('LIFECYCLE_DECISIONS.confirm keys match VALID_TRANSITIONS keys', () => {
-    const transitionKeys = Object.keys(VALID_TRANSITIONS).sort()
-    const decisionKeys = Object.keys(LIFECYCLE_DECISIONS.confirm).sort()
-    expect(decisionKeys).toEqual(transitionKeys)
-  })
-
-  it('LIFECYCLE_DECISIONS.reject keys match VALID_TRANSITIONS keys', () => {
-    const transitionKeys = Object.keys(VALID_TRANSITIONS).sort()
-    const decisionKeys = Object.keys(LIFECYCLE_DECISIONS.reject).sort()
-    expect(decisionKeys).toEqual(transitionKeys)
-  })
-
-  it('all intent rows have the same set of state keys', () => {
-    const intents = Object.keys(LIFECYCLE_DECISIONS) as Array<keyof typeof LIFECYCLE_DECISIONS>
-    const referenceKeys = Object.keys(LIFECYCLE_DECISIONS[intents[0]]).sort()
+describe("decision table key consistency", () => {
+  it("LIFECYCLE_DECISIONS.confirm keys match VALID_TRANSITIONS keys", () => {
+    const transitionKeys = Object.keys(VALID_TRANSITIONS).sort();
+    const decisionKeys = Object.keys(LIFECYCLE_DECISIONS.confirm).sort();
+    expect(decisionKeys).toEqual(transitionKeys);
+  });
+
+  it("LIFECYCLE_DECISIONS.reject keys match VALID_TRANSITIONS keys", () => {
+    const transitionKeys = Object.keys(VALID_TRANSITIONS).sort();
+    const decisionKeys = Object.keys(LIFECYCLE_DECISIONS.reject).sort();
+    expect(decisionKeys).toEqual(transitionKeys);
+  });
+
+  it("all intent rows have the same set of state keys", () => {
+    const intents = Object.keys(LIFECYCLE_DECISIONS) as Array<
+      keyof typeof LIFECYCLE_DECISIONS
+    >;
+    const referenceKeys = Object.keys(LIFECYCLE_DECISIONS[intents[0]]).sort();
     for (const intent of intents) {
-      expect(Object.keys(LIFECYCLE_DECISIONS[intent]).sort()).toEqual(referenceKeys)
+      expect(Object.keys(LIFECYCLE_DECISIONS[intent]).sort()).toEqual(
+        referenceKeys,
+      );
     }
-  })
-})
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 5. APPROVE-TRANSITION DRIFT
 // ---------------------------------------------------------------------------
-describe('approve-transition drift', () => {
-  it('every state with approve decision can transition to ready', () => {
+describe("approve-transition drift", () => {
+  it("every state with approve decision can transition to ready", () => {
     for (const state of ALL_STATES) {
-      if (LIFECYCLE_DECISIONS.confirm[state] === 'approve') {
-        expect(
-          VALID_TRANSITIONS[state].includes('ready'),
-        ).toBe(true)
+      if (LIFECYCLE_DECISIONS.confirm[state] === "approve") {
+        expect(VALID_TRANSITIONS[state].includes("ready")).toBe(true);
       }
     }
-  })
-})
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 6. APPLY_INTENT UNIT TESTS
 // ---------------------------------------------------------------------------
-describe('applyIntent', () => {
-  it('pending_confirmation + confirm = approve', () => {
-    expect(applyIntent('pending_confirmation', 'confirm')).toBe('approve')
-  })
-
-  it('expired + confirm = expired', () => {
-    expect(applyIntent('expired', 'confirm')).toBe('expired')
-  })
-
-  it('cancelled + confirm = conflict', () => {
-    expect(applyIntent('cancelled', 'confirm')).toBe('conflict')
-  })
-
-  it('ready + confirm = already_confirmed', () => {
-    expect(applyIntent('ready', 'confirm')).toBe('already_confirmed')
-  })
-
-  it('blocked_pending_approval + confirm = awaiting_approval', () => {
-    expect(applyIntent('blocked_pending_approval', 'confirm')).toBe(
-      'awaiting_approval',
-    )
-  })
-
-  it('failed_terminal + confirm = conflict', () => {
-    expect(applyIntent('failed_terminal', 'confirm')).toBe('conflict')
-  })
-
-  it('undone + confirm = conflict', () => {
-    expect(applyIntent('undone', 'confirm')).toBe('conflict')
-  })
-
-  it('pending_confirmation + reject resolves as approve (rejection uses same cancel path)', () => {
-    expect(applyIntent('pending_confirmation', 'reject')).toBe('approve')
-  })
-
-  it('expired + reject = expired', () => {
-    expect(applyIntent('expired', 'reject')).toBe('expired')
-  })
-
-  it('cancelled + reject = conflict', () => {
-    expect(applyIntent('cancelled', 'reject')).toBe('conflict')
-  })
-
-  it('ready + reject = conflict', () => {
-    expect(applyIntent('ready', 'reject')).toBe('conflict')
-  })
-
-  it('executing + reject = conflict', () => {
-    expect(applyIntent('executing', 'reject')).toBe('conflict')
-  })
-
-  it('completed + reject = conflict', () => {
-    expect(applyIntent('completed', 'reject')).toBe('conflict')
-  })
-})
+describe("applyIntent", () => {
+  it("pending_confirmation + confirm = approve", () => {
+    expect(applyIntent("pending_confirmation", "confirm")).toBe("approve");
+  });
+
+  it("expired + confirm = expired", () => {
+    expect(applyIntent("expired", "confirm")).toBe("expired");
+  });
+
+  it("cancelled + confirm = conflict", () => {
+    expect(applyIntent("cancelled", "confirm")).toBe("conflict");
+  });
+
+  it("ready + confirm = already_confirmed", () => {
+    expect(applyIntent("ready", "confirm")).toBe("already_confirmed");
+  });
+
+  it("blocked_pending_approval + confirm = awaiting_approval", () => {
+    expect(applyIntent("blocked_pending_approval", "confirm")).toBe(
+      "awaiting_approval",
+    );
+  });
+
+  it("failed_terminal + confirm = conflict", () => {
+    expect(applyIntent("failed_terminal", "confirm")).toBe("conflict");
+  });
+
+  it("undone + confirm = conflict", () => {
+    expect(applyIntent("undone", "confirm")).toBe("conflict");
+  });
+
+  it("pending_confirmation + reject resolves as approve (rejection uses same cancel path)", () => {
+    expect(applyIntent("pending_confirmation", "reject")).toBe("approve");
+  });
+
+  it("expired + reject = expired", () => {
+    expect(applyIntent("expired", "reject")).toBe("expired");
+  });
+
+  it("cancelled + reject = conflict", () => {
+    expect(applyIntent("cancelled", "reject")).toBe("conflict");
+  });
+
+  it("ready + reject = conflict", () => {
+    expect(applyIntent("ready", "reject")).toBe("conflict");
+  });
+
+  it("executing + reject = conflict", () => {
+    expect(applyIntent("executing", "reject")).toBe("conflict");
+  });
+
+  it("completed + reject = conflict", () => {
+    expect(applyIntent("completed", "reject")).toBe("conflict");
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 7. EXECUTION_ERROR TYPE TESTS
 // ---------------------------------------------------------------------------
-describe('ExecutionErrorCode', () => {
-  it('covers all expected error codes', () => {
+describe("ExecutionErrorCode", () => {
+  it("covers all expected error codes", () => {
     const codes: ExecutionErrorCode[] = [
-      'execution_expired',
-      'execution_already_confirmed',
-      'execution_awaiting_approval',
-      'execution_not_found',
-      'execution_forbidden',
-      'execution_invalid_transition',
-    ]
-    expect(codes).toHaveLength(6)
-  })
-})
+      "execution_expired",
+      "execution_already_confirmed",
+      "execution_awaiting_approval",
+      "execution_not_found",
+      "execution_forbidden",
+      "execution_invalid_transition",
+    ];
+    expect(codes).toHaveLength(6);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // 8. EXPIRY HELPER TESTS
 // ---------------------------------------------------------------------------
-describe('parseExpiresAt', () => {
-  it('returns undefined for undefined input', () => {
-    expect(parseExpiresAt(undefined)).toBeUndefined()
-  })
-
-  it('returns undefined for invalid date string', () => {
-    expect(parseExpiresAt('invalid')).toBeUndefined()
-  })
-
-  it('returns correct epoch ms for valid ISO string', () => {
-    const result = parseExpiresAt('2026-01-01T00:00:00Z')
-    expect(result).toBe(new Date('2026-01-01T00:00:00Z').getTime())
-  })
-
-  it('returns undefined for empty string', () => {
-    expect(parseExpiresAt('')).toBeUndefined()
-  })
-})
-
-describe('isConfirmationExpired', () => {
-  it('returns false for undefined expiresAtMs', () => {
-    expect(isConfirmationExpired(undefined)).toBe(false)
-  })
-
-  it('returns true for past timestamp', () => {
-    const pastMs = Date.now() - 60_000
-    expect(isConfirmationExpired(pastMs)).toBe(true)
-  })
-
-  it('returns false for future timestamp', () => {
-    const futureMs = Date.now() + 60_000
-    expect(isConfirmationExpired(futureMs)).toBe(false)
-  })
-
-  it('works with custom now parameter', () => {
-    const expiresAtMs = 1000
-    expect(isConfirmationExpired(expiresAtMs, 999)).toBe(false)
-    expect(isConfirmationExpired(expiresAtMs, 1000)).toBe(true)
-    expect(isConfirmationExpired(expiresAtMs, 1001)).toBe(true)
-  })
-})
+describe("parseExpiresAt", () => {
+  it("returns undefined for undefined input", () => {
+    expect(parseExpiresAt(undefined)).toBeUndefined();
+  });
+
+  it("returns undefined for invalid date string", () => {
+    expect(parseExpiresAt("invalid")).toBeUndefined();
+  });
+
+  it("returns correct epoch ms for valid ISO string", () => {
+    const result = parseExpiresAt("2026-01-01T00:00:00Z");
+    expect(result).toBe(new Date("2026-01-01T00:00:00Z").getTime());
+  });
+
+  it("returns undefined for empty string", () => {
+    expect(parseExpiresAt("")).toBeUndefined();
+  });
+});
+
+describe("isConfirmationExpired", () => {
+  it("returns false for undefined expiresAtMs", () => {
+    expect(isConfirmationExpired(undefined)).toBe(false);
+  });
+
+  it("returns true for past timestamp", () => {
+    const pastMs = Date.now() - 60_000;
+    expect(isConfirmationExpired(pastMs)).toBe(true);
+  });
+
+  it("returns false for future timestamp", () => {
+    const futureMs = Date.now() + 60_000;
+    expect(isConfirmationExpired(futureMs)).toBe(false);
+  });
+
+  it("works with custom now parameter", () => {
+    const expiresAtMs = 1000;
+    expect(isConfirmationExpired(expiresAtMs, 999)).toBe(false);
+    expect(isConfirmationExpired(expiresAtMs, 1000)).toBe(true);
+    expect(isConfirmationExpired(expiresAtMs, 1001)).toBe(true);
+  });
+});