feat(quality): 6A.1+6A.2 — test-discovery gate, 135 orphan tests re-wired, 2 production bug fixes, vitest in CI (#3536)

check-test-discovery gate (TDD; 195 orphans found, 135 re-wired into the node runner, 60 frozen+annotated). Triage fixed 2 real production bugs: missing BYPASS_PREFIX_NOT_ALLOWED zod refine (spawn-capable prefixes accepted into the bypass list, Hard Rules #15/#17) and resetDbInstance not firing stateReset resetters (stale schema memo → 503 instead of 403; also hit backup-restore). New test-vitest CI job: test:vitest blocking (146/146), test:vitest:ui informational (14 pre-existing fails, triage 2026-06-16).
2026-08-01 12:52:11 +03:00 · 2026-06-09 20:23:04 -03:00
parent d6dd617874
commit d1df82eca0
13 changed files with 618 additions and 39 deletions
--- a/scripts/check/check-test-discovery.mjs
+++ b/scripts/check/check-test-discovery.mjs
@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+// scripts/check/check-test-discovery.mjs
+// Gate 6A.1 — test discovery: todo arquivo *.test.ts|tsx / *.spec.ts|tsx do repo deve
+// ser COLETADO por pelo menos um runner que efetivamente RODA via npm script ou CI.
+//
+// WHY: a auditoria 2026-06-09 encontrou ≈135 testes em subdiretórios de tests/unit/
+// que nenhum runner coleta (o glob `tests/unit/*.test.ts` é top-level-only), incluindo
+// tests/unit/authz/routeGuard.test.ts (Hard Rules #15/#17) — cujos asserts JÁ FALHAM,
+// apodrecidos sem ninguém ver. Teste que não roda é o falso verde definitivo: todo o
+// investimento anti test-masking protege asserts que nem executam.
+//
+// Modelo: COLLECTORS declara explicitamente o glob de cada runner REAL + as fontes
+// (package.json / ci.yml / vitest configs) onde o padrão deve aparecer textualmente
+// (drift-check: mudou o glob na fonte sem atualizar aqui → o gate falha pedindo sync).
+// "Coletado" = casado pelo glob de um runner executado por script npm ou job de CI.
+// Includes de config que NENHUM script executa (ex.: vitest.config.ts sem filtro) NÃO
+// contam — config morta não roda teste.
+//
+// Catraca: órfãos pré-existentes ficam congelados em test-discovery-baseline.json
+// (dívida visível, decrescente). Órfão NOVO → fail. Entrada do baseline que deixou de
+// ser órfã (religada/deletada) → fail pedindo remoção (stale-allowlist enforcement).
+// --update regrava o baseline com o estado atual (use só para REMOVER religados;
+// adições novas devem ser corrigidas, não congeladas — esse é o ponto do gate).
+//
+// Limitações documentadas (v1):
+//  - `exclude` de arquivo individual em vitest configs não é modelado (1 caso hoje:
+//    providerDiversity.test.ts — coletado pelo include, deliberadamente excluído).
+//  - @omniroute/* ficam fora do walk (têm CI próprio: opencode-*-ci.yml).
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const ROOT = process.cwd();
+const BASELINE_PATH = path.resolve(
+  process.argv.includes("--baseline")
+    ? process.argv[process.argv.indexOf("--baseline") + 1]
+    : path.join(ROOT, "test-discovery-baseline.json")
+);
+const UPDATE = process.argv.includes("--update");
+
+// Raízes varridas em busca de arquivos de teste.
+const WALK_ROOTS = ["tests", "src", "open-sse", "electron", "bin"];
+const WALK_EXCLUDE = new Set(["node_modules", ".next", "dist", "coverage", ".git"]);
+const TEST_FILE_RE = /\.(test|spec)\.(ts|tsx)$/;
+
+// Runners REAIS e seus globs. `sources`: arquivos onde `anchor` (default: o próprio
+// glob) deve aparecer textualmente — se o runner mudar, este gate exige o sync.
+export const COLLECTORS = [
+  // Node native runner — test:unit / test:unit:fast / shards / test:coverage + CI (8 shards, node24, node26)
+  { glob: "tests/unit/*.test.ts", sources: ["package.json", ".github/workflows/ci.yml"] },
+  // Node native runner — subdiretórios religados pela 6A.1c (2026-06-09). Braces
+  // explícitos para NÃO incluir tests/unit/autoCombo/** (testes vitest — importam
+  // "vitest" e explodem no node runner). Subdir novo: adicione aqui E nos scripts
+  // (o drift-check + o gate de órfãos forçam a manutenção em sincronia).
+  {
+    glob: "tests/unit/{api,auth,authz,build,cli,cli-helper,compression,cors,dashboard,db,db-adapters,docs,gamification,guardrails,lib,mcp,runtime,security,services,settings,shared,ui}/**/*.test.ts",
+    sources: ["package.json", ".github/workflows/ci.yml"],
+  },
+  // Node native runner — test:integration (top-level only; tests/integration/services/ NÃO roda)
+  { glob: "tests/integration/*.test.ts", sources: ["package.json"] },
+  // Node native runner — test:system
+  { glob: "tests/e2e/system-failover.test.ts", sources: ["package.json"] },
+  // vitest.mcp.config.ts — test:vitest
+  { glob: "open-sse/mcp-server/__tests__/**/*.test.ts", sources: ["vitest.mcp.config.ts"] },
+  { glob: "open-sse/services/autoCombo/__tests__/**/*.test.ts", sources: ["vitest.mcp.config.ts"] },
+  { glob: "tests/unit/autoCombo/**/*.test.ts", sources: ["vitest.mcp.config.ts"] },
+  { glob: "tests/unit/encryption.spec.ts", sources: ["vitest.mcp.config.ts"] },
+  { glob: "src/shared/components/**/*.test.tsx", sources: ["vitest.mcp.config.ts"] },
+  { glob: "src/shared/hooks/__tests__/**/*.test.tsx", sources: ["vitest.mcp.config.ts"] },
+  { glob: "src/app/(dashboard)/**/__tests__/**/*.test.tsx", sources: ["vitest.mcp.config.ts"] },
+  // vitest.config.ts via test:vitest:ui (roda com path-filter `tests/unit/ui`, então o
+  // conjunto EFETIVO é a interseção do include `tests/unit/**/*.test.tsx` com o filtro)
+  {
+    glob: "tests/unit/ui/**/*.test.tsx",
+    sources: ["package.json", "vitest.config.ts"],
+    anchors: { "package.json": "tests/unit/ui", "vitest.config.ts": "tests/unit/**/*.test.tsx" },
+  },
+  // Playwright — test:e2e (o script passa tests/e2e/*.spec.ts; testMatch **/*.spec.ts)
+  { glob: "tests/e2e/*.spec.ts", sources: ["package.json"] },
+  // Runners custom — test:ecosystem / test:protocols:e2e (spawnam vitest com o arquivo)
+  { glob: "tests/e2e/ecosystem.test.ts", sources: ["scripts/dev/run-ecosystem-tests.mjs"] },
+  { glob: "tests/e2e/protocol-clients.test.ts", sources: ["scripts/dev/run-protocol-clients-tests.mjs"] },
+];
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+/** Converte um glob em RegExp ancorada. Suporta `*`, `**` (com ou sem barra) e `{a,b}`. */
+export function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          re += "(?:.*/)?"; // "**/" — zero ou mais diretórios
+          i += 2;
+        } else {
+          re += ".*"; // "**" solto
+          i += 1;
+        }
+      } else {
+        re += "[^/]*"; // "*" não atravessa "/"
+      }
+    } else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      const alts = glob
+        .slice(i + 1, end)
+        .split(",")
+        .map(escapeRe);
+      re += "(?:" + alts.join("|") + ")";
+      i = end;
+    } else {
+      re += escapeRe(c);
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+
+/** Arquivos de teste não casados por NENHUM glob de collector (ordem preservada). */
+export function findOrphans(files, globs) {
+  const regexes = globs.map(globToRegExp);
+  return files.filter((f) => !regexes.some((re) => re.test(f)));
+}
+
+/**
+ * Compara os órfãos atuais com o baseline congelado.
+ *  - newOrphans: órfão atual fora do baseline → teste novo que NÃO RODA (fail).
+ *  - stale: entrada do baseline que não é mais órfã (religada/deletada) → remova (fail).
+ */
+export function evaluateAgainstBaseline(orphans, baselineList) {
+  const baseSet = new Set(baselineList);
+  const orphanSet = new Set(orphans);
+  return {
+    newOrphans: orphans.filter((o) => !baseSet.has(o)),
+    stale: baselineList.filter((b) => !orphanSet.has(b)),
+  };
+}
+
+/**
+ * Drift-check: cada glob declarado (ou seu anchor por fonte) deve aparecer textualmente
+ * em TODAS as suas fontes. Retorna mensagens de drift.
+ */
+export function findCollectorDrift(collectors, contents) {
+  const drift = [];
+  for (const c of collectors) {
+    for (const source of c.sources) {
+      const anchor = c.anchors?.[source] ?? c.glob;
+      const body = contents[source];
+      if (body === undefined || !body.includes(anchor)) {
+        drift.push(
+          `glob "${c.glob}" (anchor "${anchor}") não encontrado em ${source} — o runner mudou? Sincronize COLLECTORS em check-test-discovery.mjs`
+        );
+      }
+    }
+  }
+  return drift;
+}
+
+function walk(dir, acc = []) {
+  if (!fs.existsSync(dir)) return acc;
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (WALK_EXCLUDE.has(e.name)) continue;
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) walk(p, acc);
+    else if (TEST_FILE_RE.test(e.name)) acc.push(p);
+  }
+  return acc;
+}
+
+function collectTestFiles() {
+  const out = [];
+  for (const root of WALK_ROOTS) {
+    for (const f of walk(path.join(ROOT, root))) {
+      out.push(path.relative(ROOT, f).replace(/\\/g, "/"));
+    }
+  }
+  return out.sort();
+}
+
+function main() {
+  // 1) drift dos collectors vs fontes reais
+  const contents = {};
+  for (const c of COLLECTORS) {
+    for (const s of c.sources) {
+      if (contents[s] === undefined) {
+        const p = path.join(ROOT, s);
+        contents[s] = fs.existsSync(p) ? fs.readFileSync(p, "utf8") : undefined;
+      }
+    }
+  }
+  const drift = findCollectorDrift(COLLECTORS, contents);
+
+  // 2) órfãos vs baseline
+  const files = collectTestFiles();
+  const orphans = findOrphans(
+    files,
+    COLLECTORS.map((c) => c.glob)
+  );
+  if (!fs.existsSync(BASELINE_PATH) && !UPDATE) {
+    console.error(
+      `[test-discovery] FAIL — ${path.basename(BASELINE_PATH)} ausente. Bootstrap:\n` +
+        `  node scripts/check/check-test-discovery.mjs --update  (gera o baseline com os órfãos atuais)`
+    );
+    process.exit(2);
+  }
+  const baseline = fs.existsSync(BASELINE_PATH)
+    ? JSON.parse(fs.readFileSync(BASELINE_PATH, "utf8"))
+    : {
+        _comment:
+          "Catraca de test-discovery (check-test-discovery.mjs). Cada entrada e um arquivo de teste que NENHUM runner coleta (ele nunca roda) — divida congelada na auditoria 6A.1 (2026-06-09). So pode DIMINUIR: religue o teste (ajustando o glob do runner ou movendo o arquivo) e remova a entrada via --update. NAO adicione novos orfaos — corrija o runner.",
+        orphans: [],
+      };
+  const { newOrphans, stale } = evaluateAgainstBaseline(orphans, baseline.orphans || []);
+
+  if (UPDATE && drift.length === 0) {
+    baseline.orphans = orphans;
+    fs.writeFileSync(BASELINE_PATH, JSON.stringify(baseline, null, 2) + "\n");
+    console.log(
+      `[test-discovery] baseline regravado: ${orphans.length} órfão(s) (${stale.length} removido(s), ${newOrphans.length} adicionado(s) — adições devem ser corrigidas, não congeladas)`
+    );
+    return;
+  }
+
+  const problems = [];
+  for (const d of drift) problems.push(`  ✗ [drift] ${d}`);
+  for (const o of newOrphans) {
+    problems.push(
+      `  ✗ [órfão NOVO] ${o} — nenhum runner coleta este arquivo (ele NUNCA roda). Mova-o para um path coletado ou ajuste o runner.`
+    );
+  }
+  for (const s of stale) {
+    problems.push(
+      `  ✗ [stale] ${s} — não é mais órfão (religado/removido). Remova do baseline: node scripts/check/check-test-discovery.mjs --update`
+    );
+  }
+
+  if (problems.length) {
+    console.error(`[test-discovery] ${problems.length} problema(s):\n` + problems.join("\n"));
+    process.exit(1);
+  }
+  console.log(
+    `[test-discovery] OK — ${files.length} arquivos de teste, ${COLLECTORS.length} collectors, ${(baseline.orphans || []).length} órfão(s) congelado(s) (dívida rastreada, só decresce)`
+  );
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || "").href) main();