First public release

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

test/pivot-ops.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from 'vitest'
+import { overall, validateReport } from '@extant2000/evidence-record'
+import { formatReplan, replan, toReport, type Assumption, type Plan } from '../src/index.js'
+
+const disk = (p: Partial<Assumption> = {}): Assumption => ({
+  id: 'disk-headroom',
+  description: 'the host has room for the new image',
+  condition: 'disk free bytes',
+  comparison: 'at-least',
+  required: 5_000_000_000,
+  observed: 20_000_000_000,
+  where: 'df -P /var/lib/docker',
+  ...p,
+})
+
+const plan = (assumptions: Assumption[]): Plan => ({ name: 'suite rollout', assumptions })
+
+describe('a plan that records no assumptions cannot be invalidated', () => {
+  it('holds rather than proceeding', () => {
+    const d = replan(plan([]))
+    expect(d.decision).toBe('hold')
+    expect(d.reason).toContain('cannot be invalidated cannot be trusted')
+    expect(overall(toReport(plan([])))).toBe('not-assessed')
+  })
+})
+
+describe('unread is not fine', () => {
+  it('holds — not proceeds — when a condition was never re-measured', () => {
+    const d = replan(plan([disk(), disk({ id: 'registry', observed: null })]))
+    expect(d.decision).toBe('hold')
+    expect(d.reason).toContain('decision taken on unread conditions')
+    expect(d.unverified.map(a => a.id)).toEqual(['registry'])
+  })
+
+  it('reports the unread condition as not-assessed', () => {
+    const r = toReport(plan([disk({ observed: null })]))
+    expect(r.findings[0]!.determination).toBe('not-assessed')
+    expect(r.findings[0]!.detail).toContain('"We did not look" is not "it is fine"')
+  })
+
+  it('refuses to order non-numeric values lexically', () => {
+    // A string comparison would silently pass or fail on lexical order,
+    // which is not what the plan meant.
+    const r = toReport(plan([disk({
+      condition: 'window state', comparison: 'at-least',
+      required: 'open', observed: 'closing',
+    })]))
+    expect(r.findings[0]!.determination).toBe('not-assessed')
+    expect(r.findings[0]!.detail).toContain('rather than compared lexically')
+  })
+
+  it('compares equality on non-numeric values happily', () => {
+    const ok = disk({ condition: 'window', comparison: 'equals', required: 'open', observed: 'open' })
+    expect(replan(plan([ok])).decision).toBe('proceed')
+  })
+})
+
+describe('a fallback without a floor cannot fail', () => {
+  const broken = disk({ observed: 1_000_000_000 })
+
+  it('stops on a broken assumption whose fallback has no floor', () => {
+    const d = replan(plan([{ ...broken, fallback: { description: 'reduce concurrency and continue' } }]))
+    expect(d.decision).toBe('stop')
+    const r = toReport(plan([{ ...broken, fallback: { description: 'reduce concurrency and continue' } }]))
+    expect(r.findings[0]!.severity).toBe('critical')
+    expect(r.findings[0]!.detail).toContain('a way of never stopping')
+  })
+
+  it('pivots when the fallback states a floor', () => {
+    const d = replan(plan([{
+      ...broken,
+      fallback: { description: 'reduce concurrency to 1', floor: 'stop below 500 MB free' },
+    }]))
+    expect(d.decision).toBe('pivot')
+    expect(d.reason).toContain('reduce concurrency to 1')
+  })
+
+  it('stops on a broken assumption with no fallback at all', () => {
+    const d = replan(plan([broken]))
+    expect(d.decision).toBe('stop')
+    expect(toReport(plan([broken])).findings[0]!.detail)
+      .toContain('rather than proceeding on an assumption known to be false')
+  })
+
+  it('a broken assumption outranks an unread one in the decision', () => {
+    // Stop is more urgent than hold.
+    const d = replan(plan([broken, disk({ id: 'x', observed: null })]))
+    expect(d.decision).toBe('stop')
+  })
+})
+
+describe('proceed', () => {
+  it('proceeds only when every assumption was re-checked and holds', () => {
+    const d = replan(plan([disk(), disk({ id: 'registry', condition: 'registry reachable', comparison: 'equals', required: 'yes', observed: 'yes' })]))
+    expect(d.decision).toBe('proceed')
+    expect(overall(toReport(plan([disk()])))).toBe('pass')
+  })
+
+  it('honours at-most comparisons', () => {
+    expect(replan(plan([disk({ comparison: 'at-most', required: 100, observed: 50 })])).decision).toBe('proceed')
+    expect(replan(plan([disk({ comparison: 'at-most', required: 100, observed: 150 })])).decision).toBe('stop')
+  })
+})
+
+describe('conformance with the evidence-record standard', () => {
+  it('prints the decision in the output', () => {
+    expect(formatReplan(plan([disk()]))).toContain('decision: PROCEED')
+    expect(formatReplan(plan([disk({ observed: 1 })]))).toContain('decision: STOP')
+  })
+
+  it('every conclusion carries a citation', () => {
+    expect(validateReport(toReport(plan([disk(), disk({ id: 'b', observed: 1 })])))).toEqual([])
+  })
+
+  it('carries the reading into the citation as a measurement', () => {
+    expect(formatReplan(plan([disk()]), { evidence: 'inline' })).toContain('disk free bytes = 20000000000')
+  })
+})