autotel-pact 0.2.0

package/src/cli.test.ts

@@ -0,0 +1,148 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { main } from './cli.js';
+import type { InteractionLedgerEntry, PactFile } from './types.js';
+import { LEDGER_ENTRY_SPEC } from './types.js';
+
+let workDir: string;
+let originalCwd: string;
+let stdoutChunks: string[];
+let stderrChunks: string[];
+let stdoutSpy: ReturnType<typeof vi.spyOn>;
+let stderrSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  originalCwd = process.cwd();
+  workDir = mkdtempSync(path.join(tmpdir(), 'autotel-pact-cli-'));
+  process.chdir(workDir);
+  stdoutChunks = [];
+  stderrChunks = [];
+  stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk: unknown) => {
+    stdoutChunks.push(String(chunk));
+    return true;
+  });
+  stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation((chunk: unknown) => {
+    stderrChunks.push(String(chunk));
+    return true;
+  });
+});
+
+afterEach(() => {
+  stdoutSpy.mockRestore();
+  stderrSpy.mockRestore();
+  process.chdir(originalCwd);
+  rmSync(workDir, { recursive: true, force: true });
+});
+
+function writePact(filename: string, file: PactFile): void {
+  mkdirSync('pacts', { recursive: true });
+  writeFileSync(path.join('pacts', filename), JSON.stringify(file));
+}
+
+function writeLedger(entries: InteractionLedgerEntry[]): void {
+  mkdirSync('.autotel-pact', { recursive: true });
+  writeFileSync(
+    '.autotel-pact/ledger-x.jsonl',
+    entries.map((e) => JSON.stringify(e)).join('\n') + '\n',
+  );
+}
+
+function freshEntry(overrides: Partial<InteractionLedgerEntry> = {}): InteractionLedgerEntry {
+  return {
+    type: 'interaction',
+    spec: LEDGER_ENTRY_SPEC,
+    consumer: 'A',
+    provider: 'B',
+    interaction: 'evt',
+    states: [],
+    kind: 'message',
+    source: 'test',
+    role: 'consumer',
+    outcome: 'passed',
+    duration_ms: 1,
+    observed_at: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe('cli', () => {
+  it('--help exits 0 and prints help', async () => {
+    const code = await main(['--help']);
+    expect(code).toBe(0);
+    expect(stdoutChunks.join('')).toContain('autotel-pact audit');
+  });
+
+  it('default mode prints a table and exits 0 even with stale confidence', async () => {
+    writePact('A-B.json', { consumer: { name: 'A' }, provider: { name: 'B' }, messages: [{ description: 'evt' }] });
+    const code = await main([]);
+    expect(code).toBe(0);
+    expect(stdoutChunks.join('')).toMatch(/STALE/);
+    expect(stdoutChunks.join('')).toContain('TEST_SEEN');
+  });
+
+  it('--gate exits 1 when contracted interactions are not seen in test', async () => {
+    writePact('A-B.json', { consumer: { name: 'A' }, provider: { name: 'B' }, messages: [{ description: 'evt' }] });
+    const code = await main(['--gate']);
+    expect(code).toBe(1);
+  });
+
+  it('--gate=strict also fails on observed-but-not-contracted', async () => {
+    writeLedger([freshEntry()]);
+    const code = await main(['--gate=strict']);
+    expect(code).toBe(1);
+  });
+
+  it('--gate=strict succeeds when all interactions are contracted and seen in test', async () => {
+    writePact('A-B.json', { consumer: { name: 'A' }, provider: { name: 'B' }, messages: [{ description: 'evt' }] });
+    writeLedger([freshEntry()]);
+    const code = await main(['--gate=strict']);
+    expect(code).toBe(0);
+  });
+
+  it('--json emits parseable JSON', async () => {
+    writePact('A-B.json', { consumer: { name: 'A' }, provider: { name: 'B' }, messages: [{ description: 'evt' }] });
+    const code = await main(['--json']);
+    expect(code).toBe(0);
+    const parsed = JSON.parse(stdoutChunks.join(''));
+    expect(parsed.counts.contracted_not_test_seen).toBe(1);
+    expect(parsed.spec).toContain('v0.2.0');
+  });
+
+  it('rejects unknown args with exit 2', async () => {
+    const code = await main(['--bogus']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Unknown argument/);
+  });
+
+  it('exits 2 when --pacts is given with no value', async () => {
+    const code = await main(['--pacts']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Missing value for --pacts/);
+  });
+
+  it('exits 2 when --ledger is given with no value', async () => {
+    const code = await main(['--ledger']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Missing value for --ledger/);
+  });
+
+  it('exits 2 when --pacts= is given with empty value', async () => {
+    const code = await main(['--pacts=']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Missing value for --pacts/);
+  });
+
+  it('exits 2 when --ledger= is given with empty value', async () => {
+    const code = await main(['--ledger=']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Missing value for --ledger/);
+  });
+
+  it('exits 2 when --window= is given with empty value', async () => {
+    const code = await main(['--window=']);
+    expect(code).toBe(2);
+    expect(stderrChunks.join('')).toMatch(/Missing value for --window/);
+  });
+});

package/src/cli.ts

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+import { runAudit } from './audit.js';
+import { brokerConfigFromEnv } from './broker.js';
+import { CLI_COLUMNS, formatYesNo } from './labels.js';
+import type { AuditMatrix, AuditRow } from './types.js';
+
+interface CliArgs {
+  pactsDir?: string;
+  ledgerDir?: string;
+  windowDays?: number;
+  gate: 'off' | 'on' | 'strict' | 'broker';
+  json: boolean;
+  help: boolean;
+  brokerUrl?: string;
+  brokerToken?: string;
+}
+
+const HELP_TEXT = `autotel-pact audit — runtime evidence for Pact contracts
+
+USAGE
+  autotel-pact audit [options]
+
+OPTIONS
+  --pacts <dir>         Directory containing pact files (default: ./pacts)
+  --ledger <dir>        Directory containing ledger files (default: .autotel-pact)
+  --window <days>       How many days back to consider observations recent (default: 14)
+  --gate                Exit non-zero if any contracted interaction was not seen in test
+  --gate=strict         Also exit non-zero on observations with no matching contract
+  --gate=broker         Exit non-zero if broker is configured and any row lacks broker verification
+  --broker-url <url>    Pact Broker base URL (or PACT_BROKER_BASE_URL)
+  --broker-token <tok>  Pact Broker bearer token (or PACT_BROKER_TOKEN)
+  --json                Emit machine-readable JSON instead of a table
+  --help, -h            Show this help
+
+ENVIRONMENT
+  AUTOTEL_PACT_RUN_ID         Tag ledger entries with a run id
+  AUTOTEL_PACT_LEDGER_DIR     Override default ledger directory
+  PACT_BROKER_BASE_URL        Broker base URL
+  PACT_BROKER_TOKEN           Broker bearer token
+  PACT_BROKER_USERNAME        Broker basic auth username
+  PACT_BROKER_PASSWORD        Broker basic auth password
+`;
+
+function parseDuration(value: string): number {
+  const m = /^(\d+)(d?)$/.exec(value);
+  if (!m) throw new Error(`Invalid --window value: ${value}`);
+  return Number.parseInt(m[1]!, 10);
+}
+
+function requireValue(argv: string[], i: number, flag: string): string {
+  const value = argv[i];
+  if (value === undefined || value.startsWith('--')) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = { gate: 'off', json: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    switch (a) {
+    case '--help':
+    case '-h': {
+      args.help = true;
+      break;
+    }
+    case '--json': {
+      args.json = true;
+      break;
+    }
+    case '--gate': {
+      args.gate = 'on';
+      break;
+    }
+    case '--gate=strict': {
+      args.gate = 'strict';
+      break;
+    }
+    case '--gate=broker': {
+      args.gate = 'broker';
+      break;
+    }
+    case '--pacts': {
+      args.pactsDir = requireValue(argv, ++i, '--pacts');
+      break;
+    }
+    case '--ledger': {
+      args.ledgerDir = requireValue(argv, ++i, '--ledger');
+      break;
+    }
+    case '--window': {
+      args.windowDays = parseDuration(requireValue(argv, ++i, '--window'));
+      break;
+    }
+    case '--broker-url': {
+      args.brokerUrl = requireValue(argv, ++i, '--broker-url');
+      break;
+    }
+    case '--broker-token': {
+      args.brokerToken = requireValue(argv, ++i, '--broker-token');
+      break;
+    }
+    default: {
+      if (a.startsWith('--pacts=')) {
+        const value = a.slice('--pacts='.length);
+        if (!value) throw new Error('Missing value for --pacts');
+        args.pactsDir = value;
+      } else if (a.startsWith('--ledger=')) {
+        const value = a.slice('--ledger='.length);
+        if (!value) throw new Error('Missing value for --ledger');
+        args.ledgerDir = value;
+      } else if (a.startsWith('--window=')) {
+        const value = a.slice('--window='.length);
+        if (!value) throw new Error('Missing value for --window');
+        args.windowDays = parseDuration(value);
+      } else if (a.startsWith('--broker-url=')) {
+        const value = a.slice('--broker-url='.length);
+        if (!value) throw new Error('Missing value for --broker-url');
+        args.brokerUrl = value;
+      } else if (a.startsWith('--broker-token=')) {
+        const value = a.slice('--broker-token='.length);
+        if (!value) throw new Error('Missing value for --broker-token');
+        args.brokerToken = value;
+      } else if (a === 'audit') continue;
+      else throw new Error(`Unknown argument: ${a}`);
+    }
+    }
+  }
+  return args;
+}
+
+function statusLabel(r: AuditRow): string {
+  if (r.contracted && r.test_seen) return 'OK';
+  if (r.contracted && !r.test_seen) return 'STALE';
+  return 'SHADOW';
+}
+
+function formatTable(matrix: AuditMatrix): string {
+  const lines: string[] = [
+    `Window: last ${matrix.window_days} day(s)`,
+    `Generated: ${matrix.generated_at}`,
+    '',
+  ];
+
+  if (matrix.rows.length === 0) {
+    lines.push('No contracts or observations found.');
+    return lines.join('\n');
+  }
+
+  const header = [
+    CLI_COLUMNS.STATUS,
+    CLI_COLUMNS.CONTRACTED,
+    CLI_COLUMNS.TEST_SEEN,
+    CLI_COLUMNS.PROD_SEEN,
+    CLI_COLUMNS.PROVIDER_VERIFIED,
+    CLI_COLUMNS.BROKER_VERIFIED,
+    CLI_COLUMNS.PAIR,
+    CLI_COLUMNS.KIND,
+    CLI_COLUMNS.INTERACTION,
+  ];
+  const rows = matrix.rows.map((r) => [
+    statusLabel(r),
+    formatYesNo(r.contracted),
+    formatYesNo(r.test_seen),
+    formatYesNo(r.prod_seen),
+    formatYesNo(r.provider_verified),
+    formatYesNo(r.broker_verified),
+    `${r.consumer} → ${r.provider}`,
+    r.kind,
+    r.interaction,
+  ]);
+  const widths = header.map((h, i) =>
+    Math.max(h.length, ...rows.map((row) => row[i]!.length)),
+  );
+  const fmt = (cells: string[]): string =>
+    cells.map((c, i) => c.padEnd(widths[i]!)).join('  ');
+
+  lines.push(
+    fmt(header),
+    widths.map((w) => '─'.repeat(w)).join('  '),
+    ...rows.map((r) => fmt(r)),
+    '',
+    'Summary',
+    `  Total interactions:               ${matrix.counts.total}`,
+    `  Contracted:                       ${matrix.counts.contracted}`,
+    `  Seen in test:                     ${matrix.counts.test_seen}`,
+    `  Seen in production:               ${matrix.counts.prod_seen}`,
+    `  Provider verified (interaction):  ${matrix.counts.provider_verified}`,
+    `  Broker verified (pact-pair):      ${matrix.counts.broker_verified}`,
+    `  Contracted AND seen in test:      ${matrix.counts.contracted_and_test_seen}`,
+    `  Contracted, NOT seen in test:     ${matrix.counts.contracted_not_test_seen}  ← stale confidence`,
+    `  Seen, NOT contracted:             ${matrix.counts.test_or_prod_seen_not_contracted}  ← ungoverned flow`,
+  );
+
+  if (matrix.verification_failures && matrix.verification_failures.length > 0) {
+    lines.push('', 'Provider verification failures (run-level):');
+    for (const f of matrix.verification_failures) {
+      lines.push(`  ${f.consumer} → ${f.provider}: ${f.error}`);
+    }
+  }
+
+  const brokerErrors = new Map<string, string>();
+  for (const r of matrix.rows) {
+    if (r.broker_error) {
+      brokerErrors.set(`${r.consumer} → ${r.provider}`, r.broker_error);
+    }
+  }
+  if (brokerErrors.size > 0) {
+    lines.push('', 'Broker unreachable / errored (verification status unknown):');
+    for (const [pair, err] of brokerErrors) {
+      lines.push(`  ${pair}: ${err}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function shouldFail(matrix: AuditMatrix, gate: CliArgs['gate']): boolean {
+  if (gate === 'off') return false;
+  if (matrix.counts.contracted_not_test_seen > 0) return true;
+  if (gate === 'strict' && matrix.counts.test_or_prod_seen_not_contracted > 0) return true;
+  if (gate === 'broker') {
+    const contractedRows = matrix.rows.filter((r) => r.contracted);
+    // Fail loudly on unreachable broker — a transient outage should not be
+    // silently treated as "not verified" because that would mask broker health
+    // problems behind a contract-verification message.
+    if (contractedRows.some((r) => r.broker_error)) return true;
+    if (contractedRows.some((r) => !r.broker_verified)) return true;
+  }
+  return false;
+}
+
+export async function main(argv: string[]): Promise<number> {
+  let args: CliArgs;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`${(error as Error).message}\n\n${HELP_TEXT}`);
+    return 2;
+  }
+
+  if (args.help) {
+    process.stdout.write(HELP_TEXT);
+    return 0;
+  }
+
+  const envBroker = brokerConfigFromEnv();
+  const broker =
+    args.brokerUrl || envBroker
+      ? {
+          baseUrl: args.brokerUrl ?? envBroker!.baseUrl,
+          token: args.brokerToken ?? envBroker?.token,
+          username: envBroker?.username,
+          password: envBroker?.password,
+        }
+      : undefined;
+
+  const matrix = await runAudit({
+    pactsDir: args.pactsDir,
+    dir: args.ledgerDir,
+    windowDays: args.windowDays,
+    broker,
+  });
+
+  if (args.json) {
+    process.stdout.write(JSON.stringify(matrix, null, 2) + '\n');
+  } else {
+    process.stdout.write(formatTable(matrix) + '\n');
+  }
+
+  return shouldFail(matrix, args.gate) ? 1 : 0;
+}
+
+const isDirectInvocation =
+  typeof process !== 'undefined' &&
+  process.argv[1] &&
+  (process.argv[1].endsWith('cli.js') || process.argv[1].endsWith('autotel-pact'));
+
+if (isDirectInvocation) {
+  main(process.argv.slice(2))
+    .then((code) => process.exit(code))
+    .catch((error) => {
+      console.error(error);
+      process.exit(1);
+    });
+}

package/src/index.ts

@@ -0,0 +1,94 @@
+export { withPactInteraction } from './wrapper.js';
+export type {
+  WithPactInteractionOptions,
+  MessageConsumerPactLike,
+  PactMessageHandler,
+  ReifiedMessage,
+} from './wrapper.js';
+
+export { withHttpPactInteraction } from './wrapper-http.js';
+export type {
+  WithHttpPactInteractionOptions,
+  HttpPactLike,
+  HttpInteraction,
+  HttpMockServer,
+  HttpPactTestFn,
+} from './wrapper-http.js';
+
+export { withProviderVerification } from './wrapper-provider.js';
+export type {
+  WithProviderVerificationOptions,
+  VerifierOptionsLike,
+  VerifierLike,
+  VerifierConstructor,
+} from './wrapper-provider.js';
+
+export {
+  appendLedgerEntry,
+  /**
+   * Append a ledger record without blocking the caller. Shares an internal
+   * serialized write chain with `PactLedgerSpanProcessor`; call
+   * `flushLedgerWrites()` to wait for all pending writes to land.
+   */
+  appendLedgerEntryAsync,
+  appendProviderVerificationFailure,
+  readLedger,
+  ledgerPath,
+  /** Awaits the shared async write chain used by `appendLedgerEntryAsync`. */
+  flushLedgerWrites,
+} from './ledger.js';
+export type { LedgerOptions } from './ledger.js';
+
+export { buildPactAttributes, outcomeAttribute, PACT_ATTRS } from './attrs.js';
+export type { PactAttributeKey } from './attrs.js';
+
+export { tagPactInteraction } from './tag.js';
+
+export { PactLedgerSpanProcessor, createPactLedgerProcessor } from './processor.js';
+export type {
+  PactLedgerProcessorOptions,
+  ReadableSpanLike,
+  SpanProcessorLike,
+} from './processor.js';
+
+export { runAudit, runAuditSync, computeAuditMatrix, keyOf } from './audit.js';
+export type { AuditOptions } from './audit.js';
+
+export {
+  fetchBrokerVerifications,
+  parseBrokerVerificationResult,
+  brokerConfigFromEnv,
+} from './broker.js';
+export type { BrokerConfig, ConsumerProviderPair } from './broker.js';
+
+export {
+  interactionsFromPactFile,
+  listPactFiles,
+  parsePactFile,
+} from './pact-file.js';
+
+export {
+  LEDGER_ENTRY_SPEC,
+  AUDIT_MATRIX_SPEC,
+  isInteractionLedgerEntry,
+  isProviderVerificationRun,
+} from './types.js';
+export type {
+  PactKind,
+  PactOutcome,
+  PactInteractionMeta,
+  InteractionLedgerEntry,
+  LedgerRecord,
+  ProviderVerificationRunEntry,
+  LedgerSource,
+  LedgerRole,
+  PactFile,
+  AuditRow,
+  AuditMatrix,
+  BrokerVerification,
+  PactInteractionKey,
+} from './types.js';
+
+// Downstream consumers building dashboards that explain why a broker
+// verification is pair-level (not interaction-level) can surface this warning.
+export { BROKER_GRANULARITY_WARNING } from './labels.js';

package/src/labels.ts

@@ -0,0 +1,25 @@
+/**
+ * Human-facing labels for CLI and docs. Internal JSON keeps machine keys.
+ */
+
+export const CLI_COLUMNS = {
+  STATUS: 'STATUS',
+  CONTRACTED: 'CONTRACTED',
+  TEST_SEEN: 'TEST_SEEN',
+  PROD_SEEN: 'PROD_SEEN',
+  PROVIDER_VERIFIED: 'PROVIDER_VERIFIED',
+  BROKER_VERIFIED: 'BROKER_VERIFIED',
+  PAIR: 'CONSUMER → PROVIDER',
+  KIND: 'KIND',
+  INTERACTION: 'INTERACTION',
+} as const;
+
+export function formatYesNo(value: boolean): string {
+  return value ? 'yes' : 'no';
+}
+
+export const EVIDENCE_THEME =
+  'We do not guess. We record evidence.';
+
+export const BROKER_GRANULARITY_WARNING =
+  'Broker verification proves the latest pact between a consumer and provider was verified. It does not prove each interaction was individually observed by autotel-pact.';

package/src/ledger-normalize.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'vitest';
+import { normalizeLedgerRecord } from './ledger-normalize.js';
+import { AUDIT_MATRIX_SPEC, LEDGER_ENTRY_SPEC } from './types.js';
+
+describe('normalizeLedgerRecord', () => {
+  it('accepts a current v0.2 interaction entry unchanged', () => {
+    const result = normalizeLedgerRecord({
+      type: 'interaction',
+      spec: LEDGER_ENTRY_SPEC,
+      consumer: 'A',
+      provider: 'B',
+      interaction: 'evt',
+      states: ['ready'],
+      kind: 'message',
+      outcome: 'passed',
+      source: 'test',
+      role: 'consumer',
+      duration_ms: 12,
+      observed_at: '2026-05-28T00:00:00Z',
+    });
+    expect(result).toMatchObject({
+      type: 'interaction',
+      spec: LEDGER_ENTRY_SPEC,
+      source: 'test',
+      role: 'consumer',
+      kind: 'message',
+    });
+  });
+
+  it('rejects v0.1 spec strings (legacy support removed)', () => {
+    expect(
+      normalizeLedgerRecord({
+        spec: 'autotel-pact-ledger-entry/v0.1.0',
+        consumer: 'A',
+        provider: 'B',
+        interaction: 'evt',
+        kind: 'message',
+        outcome: 'passed',
+        duration_ms: 0,
+        observed_at: '2026-05-28T00:00:00Z',
+      }),
+    ).toBeNull();
+  });
+
+  it('rejects schema_version: 1 legacy rows', () => {
+    expect(
+      normalizeLedgerRecord({
+        schema_version: 1,
+        consumer: 'A',
+        provider: 'B',
+        interaction: 'evt',
+        observed_at: '2026-05-28T00:00:00Z',
+      }),
+    ).toBeNull();
+  });
+
+  it('defaults missing states to [] and missing duration_ms to 0', () => {
+    const result = normalizeLedgerRecord({
+      spec: LEDGER_ENTRY_SPEC,
+      consumer: 'A',
+      provider: 'B',
+      interaction: 'evt',
+      outcome: 'passed',
+      observed_at: '2026-05-28T00:00:00Z',
+    });
+    expect(result).not.toBeNull();
+    if (result && result.type !== 'provider_verification_run') {
+      expect(result.states).toEqual([]);
+      expect(result.duration_ms).toBe(0);
+      expect(result.kind).toBe('message');
+    }
+  });
+
+  it('rejects unknown spec strings', () => {
+    expect(
+      normalizeLedgerRecord({
+        spec: 'autotel-pact-ledger-entry/v9.9.9',
+        consumer: 'A',
+        provider: 'B',
+        interaction: 'evt',
+      }),
+    ).toBeNull();
+  });
+
+  it('rejects entries with missing required fields', () => {
+    expect(
+      normalizeLedgerRecord({
+        spec: LEDGER_ENTRY_SPEC,
+        consumer: 'A',
+        // provider missing
+        interaction: 'evt',
+      }),
+    ).toBeNull();
+  });
+
+  it('returns null for non-object input', () => {
+    expect(normalizeLedgerRecord(null)).toBeNull();
+    expect(normalizeLedgerRecord('string')).toBeNull();
+    expect(normalizeLedgerRecord(42)).toBeNull();
+  });
+
+  it('preserves a provider_verification_run entry', () => {
+    const result = normalizeLedgerRecord({
+      type: 'provider_verification_run',
+      spec: LEDGER_ENTRY_SPEC,
+      consumer: 'A',
+      provider: 'B',
+      error: 'verifier crashed',
+      observed_at: '2026-05-28T00:00:00Z',
+    });
+    expect(result).toMatchObject({
+      type: 'provider_verification_run',
+      outcome: 'failed',
+      role: 'provider',
+      error: 'verifier crashed',
+    });
+  });
+
+  it('rejects provider_verification_run with missing error', () => {
+    expect(
+      normalizeLedgerRecord({
+        type: 'provider_verification_run',
+        spec: LEDGER_ENTRY_SPEC,
+        consumer: 'A',
+        provider: 'B',
+        observed_at: '2026-05-28T00:00:00Z',
+      }),
+    ).toBeNull();
+  });
+
+  it('does not migrate spec when audit-matrix spec given (rejects)', () => {
+    expect(
+      normalizeLedgerRecord({
+        spec: AUDIT_MATRIX_SPEC,
+        consumer: 'A',
+        provider: 'B',
+        interaction: 'evt',
+      }),
+    ).toBeNull();
+  });
+});