@daniellins/power-claude 0.16.3

package/scripts/pod-export-release.test.cjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * pod-export-release.test.cjs — teste-guarda HERMÉTICO do mecanismo de release + selo (SF10.6).
+ *
+ * SEM API real, SEM rede (endpoint do compile mockado via checkEndpoint:false), SEM sessão real
+ * de pc-arena (os experimentos são construídos com o próprio motor arena.cjs, notas fabricadas).
+ * O lado EXPORT é injetado (deps.runExport) — o drive real do bundle é SF10.7. Fixture de pod =
+ * template/pods/content-carousel (mesma da suíte de compile).
+ *
+ * Cobre: AC1 (compile fresco por import), AC2 (G5 verde + cada divergência = VERMELHO com campo),
+ * AC3 (arena reveal-gate/verdictForAxis; ausência/incompleto/BASELINE-vence = VERMELHO), AC4
+ * (selo aditivo só com ambos verdes; hashes de conteúdo intocados; VERMELHO não altera o lock),
+ * AC5 (AUTO detecta-e-bloqueia / no-op), AC6 (MANUAL mesmo code-path).
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const R = require('./pod-export-release.cjs');
+const compileMod = require('./pod-export-compile.cjs');
+const arena = require('./arena.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const FIXTURE_POD = path.join(REPO_ROOT, 'template', 'pods', 'content-carousel');
+const ARTS = ['p1.html', 'p2.html', 'p3.html', 'p4.html', 'p5.html', 'p6.html', 'p7.html'];
+
+let failures = 0;
+function assert(ok, msg) {
+  if (ok) console.log(`[OK   ] ${msg}`);
+  else { console.error(`[FALHA] ${msg}`); failures++; }
+}
+function tmpDir(label) { return fs.mkdtempSync(path.join(os.tmpdir(), `sf10_6-${label}-`)); }
+
+// ---------------------------------------------------------------------------
+// Helpers de fixture.
+// ---------------------------------------------------------------------------
+
+/** Recompila a fixture hermética e devolve o lock esperado (determinístico). */
+async function freshCompile() {
+  const { lock } = await compileMod.compile(FIXTURE_POD, { checkEndpoint: false });
+  return lock;
+}
+
+/** baseline.manifest.json (schema DF4-2) coerente com um lock; overrides p/ forçar divergências. */
+function writeBaseline(dir, lock, over = {}) {
+  fs.mkdirSync(dir, { recursive: true });
+  const manifest = {
+    pod_sha: lock.pod_sha,
+    inputs: { scenario: 'pinned' },
+    modelo_pinado: lock.modelo_pinado,
+    artifacts: ARTS.slice(),
+    vetos: { digest: 'green', visuals: 'green', assembly: 'green' },
+    complete: true,
+    ...over,
+  };
+  fs.writeFileSync(path.join(dir, 'baseline.manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
+  return dir;
+}
+
+/** Manifesto EXPORT (o que o executor produziria) — injetado via deps.runExport. */
+function exportManifestOf(lock, over = {}) {
+  return { pod_sha: lock.pod_sha, modelo_pinado: lock.modelo_pinado, artifacts: ARTS.slice(), complete: true, ...over };
+}
+function runExportStub(manifest) { return async () => manifest; }
+
+/**
+ * Constrói um experimento pc-arena REAL (motor arena.cjs) com desfecho determinístico.
+ * winner: 'EXPORT' | 'BASELINE' | 'TIE'. reveal: se false, deixa não-revelado. complete:false
+ * deixa a última rodada sem pontuar (reveal-gate bloqueado).
+ */
+function buildArena(dir, { winner = 'EXPORT', reveal = true, complete = true } = {}) {
+  const rounds = 2;
+  const rubric = { scale: 5, dimensions: [{ name: 'qualidade', weight: 1, type: 'human' }], verdict: { minDiff: 0.3, kOfN: 1 } };
+  arena.init(dir, { arms: [R.ARM_EXPORT, R.ARM_BASELINE], rounds, rubric, labels: ['W', 'X'], seed: 42 });
+  const sealed = JSON.parse(fs.readFileSync(arena.sealedPath(dir), 'utf8')); // fixture: o "operador" conhece o mapa
+  const roundsToScore = complete ? rounds : rounds - 1;
+  for (let r = 1; r <= roundsToScore; r++) {
+    const map = sealed[String(r)]; // label -> arm
+    for (const label of ['W', 'X']) {
+      const arm = map[label];
+      let score;
+      if (winner === 'TIE') score = 4;
+      else if (winner === 'EXPORT') score = arm === R.ARM_EXPORT ? 5 : 3;
+      else score = arm === R.ARM_BASELINE ? 5 : 3; // BASELINE vence
+      arena.recordScore(dir, r, label, { qualidade: score });
+    }
+  }
+  if (reveal && complete) arena.reveal(dir);
+  return dir;
+}
+
+// ---------------------------------------------------------------------------
+// Unidade: G5-determinístico (DF4-2).
+// ---------------------------------------------------------------------------
+
+async function unitG5() {
+  console.log('\n--- Unidade: compareG5 (DF4-2) ---');
+  const lock = await freshCompile();
+  const sha = lock.pod_sha;
+  const base = { pod_sha: sha, modelo_pinado: lock.modelo_pinado, artifacts: ARTS.slice(), vetos: { a: 'green', b: 'green', c: 'green' }, complete: true };
+  const exp = exportManifestOf(lock);
+
+  assert(R.compareG5(exp, base, sha, lock.modelo_pinado).verdict === 'green', 'G5 VERDE quando inventário/vetos/modelo/pod_sha coincidem');
+
+  const rBaseSha = R.compareG5(exp, { ...base, pod_sha: 'deadbeef' }, sha, lock.modelo_pinado);
+  assert(rBaseSha.verdict === 'red' && rBaseSha.divergence === 'pod_sha', 'G5 VERMELHO: baseline.pod_sha != sealed_pod_sha (binding de versão)');
+
+  const rExpSha = R.compareG5({ ...exp, pod_sha: 'cafe' }, base, sha, lock.modelo_pinado);
+  assert(rExpSha.verdict === 'red' && rExpSha.divergence === 'pod_sha', 'G5 VERMELHO: export.pod_sha != sealed_pod_sha');
+
+  const rBaseCount = R.compareG5(exp, { ...base, artifacts: ARTS.slice(0, 6) }, sha, lock.modelo_pinado);
+  assert(rBaseCount.verdict === 'red' && rBaseCount.divergence === 'inventario', 'G5 VERMELHO: inventário BASELINE != 7');
+
+  const rExpCount = R.compareG5({ ...exp, artifacts: ARTS.slice(0, 5) }, base, sha, lock.modelo_pinado);
+  assert(rExpCount.verdict === 'red' && rExpCount.divergence === 'inventario', 'G5 VERMELHO: inventário EXPORT != 7');
+
+  const rDiffSet = R.compareG5({ ...exp, artifacts: [...ARTS.slice(0, 6), 'x.html'] }, base, sha, lock.modelo_pinado);
+  assert(rDiffSet.verdict === 'red' && rDiffSet.divergence === 'inventario', 'G5 VERMELHO: conjuntos de peças divergem');
+
+  const rExpIncomplete = R.compareG5({ ...exp, complete: false }, base, sha, lock.modelo_pinado);
+  assert(rExpIncomplete.verdict === 'red' && rExpIncomplete.divergence === 'vetos', 'G5 VERMELHO: run EXPORT não atingiu complete');
+
+  const rVetoRed = R.compareG5(exp, { ...base, vetos: { a: 'green', b: 'red', c: 'green' } }, sha, lock.modelo_pinado);
+  assert(rVetoRed.verdict === 'red' && rVetoRed.divergence === 'vetos', 'G5 VERMELHO: veto não-verde no BASELINE');
+
+  const rBaseIncomplete = R.compareG5(exp, { ...base, complete: false }, sha, lock.modelo_pinado);
+  assert(rBaseIncomplete.verdict === 'red' && rBaseIncomplete.divergence === 'vetos', 'G5 VERMELHO: BASELINE não complete');
+
+  const rModel = R.compareG5(exp, { ...base, modelo_pinado: { agents: { x: 'outro' }, image: 'z' } }, sha, lock.modelo_pinado);
+  assert(rModel.verdict === 'red' && rModel.divergence === 'modelo_pinado', 'G5 VERMELHO: modelo pinado do BASELINE != lock');
+
+  const rModelExp = R.compareG5({ ...exp, modelo_pinado: { agents: { x: 'y' }, image: 'z' } }, base, sha, lock.modelo_pinado);
+  assert(rModelExp.verdict === 'red' && rModelExp.divergence === 'modelo_pinado', 'G5 VERMELHO: modelo usado no EXPORT != lock');
+}
+
+// ---------------------------------------------------------------------------
+// Unidade: veredito pc-arena (DF4-3).
+// ---------------------------------------------------------------------------
+
+function unitArena() {
+  console.log('\n--- Unidade: arenaVerdict (DF4-3) ---');
+
+  const green = buildArena(tmpDir('arena-green'), { winner: 'EXPORT' });
+  const gv = R.arenaVerdict(green);
+  assert(gv.verdict === 'green' && gv.winner === 'B', 'ARENA VERDE: EXPORT vence a cega (winner B)');
+
+  const tie = buildArena(tmpDir('arena-tie'), { winner: 'TIE' });
+  assert(R.arenaVerdict(tie).verdict === 'green', 'ARENA VERDE: empate = export em paridade-ou-melhor');
+
+  const red = buildArena(tmpDir('arena-red'), { winner: 'BASELINE' });
+  const rv = R.arenaVerdict(red);
+  assert(rv.verdict === 'red' && rv.winner === 'A' && /BASELINE SUPERA/.test(rv.message), 'ARENA VERMELHO: BASELINE supera o EXPORT');
+
+  const incomplete = buildArena(tmpDir('arena-incompleto'), { winner: 'EXPORT', reveal: false, complete: false });
+  assert(R.arenaVerdict(incomplete).verdict === 'red', 'ARENA VERMELHO: experimento incompleto (reveal-gate)');
+
+  const unrevealed = buildArena(tmpDir('arena-naorevelado'), { winner: 'EXPORT', reveal: false, complete: true });
+  assert(R.arenaVerdict(unrevealed).verdict === 'red', 'ARENA VERMELHO: completo mas NÃO revelado (nunca revela pelo release)');
+
+  assert(R.arenaVerdict(path.join(os.tmpdir(), 'nao-existe-xyz')).verdict === 'red', 'ARENA VERMELHO: diretório ausente (nunca default-verde)');
+  assert(R.arenaVerdict(undefined).verdict === 'red', 'ARENA VERMELHO: --arena-dir ausente');
+}
+
+// ---------------------------------------------------------------------------
+// Integração: release() — os 2 gatilhos, o selo aditivo, os bloqueios.
+// ---------------------------------------------------------------------------
+
+async function integration() {
+  console.log('\n--- Integração: release() ---');
+  const lock = await freshCompile();
+
+  // (AC4/AC6) MANUAL VERDE → sela; selo aditivo; hashes de conteúdo intocados.
+  {
+    const root = tmpDir('manual-green');
+    const lockPath = path.join(root, 'exports', 'content-carousel', 'export.lock.json');
+    const arenaDir = buildArena(tmpDir('ag'), { winner: 'EXPORT' });
+    const baselineDir = writeBaseline(tmpDir('bg'), lock);
+    const logs = [];
+    const r = await R.release('content-carousel', {
+      repoRoot: root, podDir: FIXTURE_POD, lockPath, checkEndpoint: false,
+      baselineDir, arenaDir, now: '2026-07-31T00:00:00.000Z', sealedBy: 'Daniel',
+      deps: { runExport: runExportStub(exportManifestOf(lock)) },
+      log: (m) => logs.push(m),
+    });
+    assert(r.status === 'sealed', 'MANUAL VERDE → status sealed');
+    const written = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    assert(written.release && written.release.status === 'sealed' && written.release.trigger === 'manual', 'lock ganhou release.status=sealed, trigger=manual');
+    assert(written.release.sealed_pod_sha === lock.pod_sha, 'sealed_pod_sha == lock.pod_sha');
+    assert(written.release.evidence.g5.sha256 && written.release.evidence.arena.sealed_map_sha256, 'evidência referenciada por sha256 (G5 + sealed-map da arena)');
+    // Selo ADITIVO: removido o campo release, o lock é IDÊNTICO ao fresco (nenhum hash poluído).
+    const { release, ...content } = written;
+    assert(JSON.stringify(content) === JSON.stringify(lock), 'selo ADITIVO: pod_sha/per_file_sha/bundle_hashes/modelo IDÊNTICOS antes/depois (voláteis fora do hash)');
+    // Evidência G5 existe no path referenciado, com o sha256 registrado.
+    const evAbs = path.join(root, 'exports', 'content-carousel', written.release.evidence.g5.path);
+    assert(fs.existsSync(evAbs), 'arquivo de evidência G5 gravado no path do selo');
+  }
+
+  // (AC4) MANUAL G5 VERMELHO (baseline de OUTRO pod_sha) → NÃO sela; lock intocado.
+  {
+    const root = tmpDir('manual-g5red');
+    const lockPath = path.join(root, 'exports', 'content-carousel', 'export.lock.json');
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    fs.writeFileSync(lockPath, '{"pod_sha":"PRE-EXISTENTE"}\n'); // selo/lock anterior
+    const arenaDir = buildArena(tmpDir('ar'), { winner: 'EXPORT' });
+    const baselineDir = writeBaseline(tmpDir('br'), lock, { pod_sha: 'OUTRA-VERSAO' });
+    const r = await R.release('content-carousel', {
+      repoRoot: root, podDir: FIXTURE_POD, lockPath, checkEndpoint: false,
+      baselineDir, arenaDir, deps: { runExport: runExportStub(exportManifestOf(lock)) }, log: () => {},
+    });
+    assert(r.status === 'red' && r.g5.verdict === 'red', 'MANUAL G5 VERMELHO → status red, sem selo');
+    assert(fs.readFileSync(lockPath, 'utf8').includes('PRE-EXISTENTE'), 'VERMELHO NÃO altera o lock pré-existente');
+  }
+
+  // (AC3/AC4) MANUAL ARENA VERMELHO (G5 verde) → NÃO sela.
+  {
+    const root = tmpDir('manual-arenared');
+    const lockPath = path.join(root, 'exports', 'content-carousel', 'export.lock.json');
+    const arenaDir = buildArena(tmpDir('aar'), { winner: 'BASELINE' });
+    const baselineDir = writeBaseline(tmpDir('bar'), lock);
+    const r = await R.release('content-carousel', {
+      repoRoot: root, podDir: FIXTURE_POD, lockPath, checkEndpoint: false,
+      baselineDir, arenaDir, deps: { runExport: runExportStub(exportManifestOf(lock)) }, log: () => {},
+    });
+    assert(r.status === 'red' && r.arena.verdict === 'red' && r.g5.verdict === 'green', 'MANUAL ARENA VERMELHO (G5 verde) → status red, sem selo');
+    assert(!fs.existsSync(lockPath), 'ARENA VERMELHO não escreve lock novo');
+  }
+
+  // (AC5) AUTO com pod_sha DIVERGENTE → BLOQUEIA e sinaliza, NUNCA sela.
+  {
+    const root = tmpDir('auto-block');
+    const lockPath = path.join(root, 'exports', 'content-carousel', 'export.lock.json');
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const stale = { ...lock, pod_sha: 'ANTIGO-DIVERGENTE' };
+    fs.writeFileSync(lockPath, compileMod.serializeLock(stale));
+    const r = await R.release('content-carousel', {
+      repoRoot: root, podDir: FIXTURE_POD, lockPath, checkEndpoint: false, ifChanged: true, log: () => {},
+    });
+    assert(r.status === 'blocked' && r.changed === true, 'AUTO pod_sha divergente → status blocked (detecta-e-bloqueia)');
+    assert(fs.readFileSync(lockPath, 'utf8').includes('ANTIGO-DIVERGENTE'), 'AUTO bloqueado NÃO sela / NÃO altera o lock');
+    const written = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    assert(!written.release, 'AUTO NUNCA escreve release unattended (DF4-4)');
+  }
+
+  // (AC5) AUTO SEM mudança → no-op informativo, nada resela.
+  {
+    const root = tmpDir('auto-noop');
+    const lockPath = path.join(root, 'exports', 'content-carousel', 'export.lock.json');
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    fs.writeFileSync(lockPath, compileMod.serializeLock(lock)); // pod_sha idêntico ao fresco
+    const before = fs.readFileSync(lockPath, 'utf8');
+    const r = await R.release('content-carousel', {
+      repoRoot: root, podDir: FIXTURE_POD, lockPath, checkEndpoint: false, ifChanged: true, log: () => {},
+    });
+    assert(r.status === 'noop' && r.changed === false, 'AUTO sem mudança → status noop');
+    assert(fs.readFileSync(lockPath, 'utf8') === before, 'AUTO no-op não reescreve o lock');
+  }
+}
+
+(async () => {
+  await unitG5();
+  unitArena();
+  await integration();
+  console.log(`\n${failures === 0 ? '[PASS]' : '[FAIL]'} pod-export-release.test.cjs — ${failures} falha(s).`);
+  process.exit(failures === 0 ? 0 : 1);
+})().catch((e) => { console.error('[ERRO FATAL]', e); process.exit(1); });