mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-07-26 09:52:11 +03:00
250 lines
11 KiB
JavaScript
250 lines
11 KiB
JavaScript
#!/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, "config/quality/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,combo,compression,correctness,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();
|