Kjell Tore Guttormsen
dec8a13952
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012HzGPGJ81k1BkUC6UvgX4Y
312 lines
12 KiB
JavaScript
312 lines
12 KiB
JavaScript
// okf-check.test.mjs
|
|
// Tester OKF-mekanismen (Step 6): okf-index genererer index.md per nivaa i ekte
|
|
// OKF-form, og okf-check validerer at hver konsept-fil baerer `type:`.
|
|
// okf-index kjoeres mot en TEMP-KOPI av okf-realistic (cpSync) saa de committede
|
|
// fixturene (lest read-only av okf-retrieval.test.mjs, m/ en bevisst dangling-link)
|
|
// forblir uroert. okf-check kjoeres som subprosess for aa fange exit-koden (kontrakt).
|
|
// Zero npm deps. Plassert i tests/ (samme moenster som org-profile-write.test.mjs).
|
|
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { execFileSync } from 'node:child_process';
|
|
import {
|
|
mkdtempSync, cpSync, writeFileSync, readFileSync, existsSync, readdirSync, rmSync, mkdirSync,
|
|
} from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join, dirname } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { generateIndexes } from '../scripts/okf-index.mjs';
|
|
|
|
const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
const CHECK = join(ROOT, 'scripts', 'okf-check.mjs');
|
|
const REALISTIC = join(ROOT, 'tests', 'fixtures', 'okf-realistic');
|
|
|
|
function tmpRoot() {
|
|
return mkdtempSync(join(tmpdir(), 'okf-'));
|
|
}
|
|
|
|
// Kjoer okf-check som subprosess; fang non-zero exit (execFileSync kaster da).
|
|
// extra: ekstra CLI-flagg (f.eks. '--strict-ingest').
|
|
function runCheck(root, ...extra) {
|
|
try {
|
|
const stdout = execFileSync('node', [CHECK, root, ...extra], { encoding: 'utf8' });
|
|
return { status: 0, stdout };
|
|
} catch (e) {
|
|
return { status: e.status ?? 1, stdout: `${e.stdout || ''}${e.stderr || ''}` };
|
|
}
|
|
}
|
|
|
|
// Bygg en ren ingestion-bundle: kanoniske vokab-typer + en trygg, on-disk relasjon.
|
|
function buildCleanIngest(dir) {
|
|
mkdirSync(join(dir, 'strategisk-kontekst'), { recursive: true });
|
|
mkdirSync(join(dir, 'dokumenter'), { recursive: true });
|
|
writeFileSync(join(dir, 'index.md'), '# Bundle\n\nokf_version: kb-layout-2026-06\n');
|
|
writeFileSync(
|
|
join(dir, 'strategisk-kontekst', 'tildelingsbrev.md'),
|
|
'---\ntype: Tildelingsbrev\nresource: urn:okr:tb\ntitle: Tildelingsbrev 2026\n'
|
|
+ "description: Styringssignaler.\ntimestamp: '2026-01-15T09:00:00+00:00'\n---\n"
|
|
+ '# Tildelingsbrev 2026\n\nHoveddokument.\n',
|
|
);
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'notat.md'),
|
|
'---\ntype: Notat\nresource: urn:okr:notat\ntitle: Internt notat\n'
|
|
+ "description: Et notat.\ntimestamp: '2026-02-01T09:00:00+00:00'\n---\n"
|
|
+ '# Internt notat\n\n## Relaterte dokumenter\n\n'
|
|
+ '- [Tildelingsbrev 2026](/strategisk-kontekst/tildelingsbrev.md)\n',
|
|
);
|
|
}
|
|
|
|
// Alle kataloger under root (inkl. root selv), rekursivt.
|
|
function allDirs(root) {
|
|
const out = [root];
|
|
for (const e of readdirSync(root, { withFileTypes: true })) {
|
|
if (e.isDirectory()) out.push(...allDirs(join(root, e.name)));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// Byte-snapshot av alle index.md under root (for idempotens-sammenligning).
|
|
function snapshotIndexes(root) {
|
|
return allDirs(root)
|
|
.map((d) => join(d, 'index.md'))
|
|
.filter((p) => existsSync(p))
|
|
.sort()
|
|
.map((p) => `${p}\n${readFileSync(p, 'utf8')}`)
|
|
.join('\n=====\n');
|
|
}
|
|
|
|
// --- okf-index ---
|
|
|
|
test('okf-index: genererer index.md per nivaa (hver katalog) i temp-kopi', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
generateIndexes(dir);
|
|
for (const d of allDirs(dir)) {
|
|
assert.ok(existsSync(join(d, 'index.md')), `index.md skal finnes i ${d}`);
|
|
}
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-index: entry-linjer matcher OKF-form `* [t](l) - d`, uten frontmatter', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
generateIndexes(dir);
|
|
const sk = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
|
|
assert.ok(!sk.startsWith('---'), 'index.md skal IKKE ha frontmatter');
|
|
const entries = sk.split('\n').filter((l) => l.startsWith('* '));
|
|
assert.ok(entries.length >= 3, 'strategisk-kontekst skal liste sine 3 konsept-filer');
|
|
for (const l of entries) {
|
|
assert.match(l, /^\* \[[^\]]+\]\([^)]+\) - .+$/, `OKF-form: ${l}`);
|
|
}
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-index: rot-index baerer okf_version, undernivaa gjoer ikke', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
generateIndexes(dir);
|
|
const root = readFileSync(join(dir, 'index.md'), 'utf8');
|
|
assert.match(root, /^okf_version:\s*\S+/m, 'rot-index skal ha okf_version');
|
|
const sub = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
|
|
assert.ok(!/^okf_version:/m.test(sub), 'undernivaa skal IKKE ha okf_version');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-index: konsept-tittel/beskrivelse hentes fra frontmatter', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
generateIndexes(dir);
|
|
const sk = readFileSync(join(dir, 'strategisk-kontekst', 'index.md'), 'utf8');
|
|
assert.match(
|
|
sk,
|
|
/\* \[Tildelingsbrev 2026\]\(tildelingsbrev-2026\.md\) - Departementets/,
|
|
'entry skal bruke frontmatter-title + -description + lenke til konsept-fil',
|
|
);
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// --- okf-check ---
|
|
|
|
test('okf-check: gyldig bundle (alle konsept har type:) -> exit 0, «0 filer uten type:»', () => {
|
|
const { status, stdout } = runCheck(REALISTIC);
|
|
assert.equal(status, 0, 'gyldig bundle skal gi exit 0');
|
|
assert.match(stdout, /0 filer uten type:/, 'skal rapportere null manglende type');
|
|
});
|
|
|
|
test('okf-check: konsept-fil uten type: -> exit != 0 + teller > 0 + navngir filen', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
writeFileSync(
|
|
join(dir, 'strategisk-kontekst', 'mangler-type.md'),
|
|
'---\ntitle: Uten type\ndescription: En konsept-fil uten paakrevd type.\n---\n# Uten type\n',
|
|
);
|
|
const { status, stdout } = runCheck(dir);
|
|
assert.notEqual(status, 0, 'type-loes fil skal gi exit != 0');
|
|
assert.match(stdout, /[1-9]\d* filer uten type:/, 'teller skal vaere > 0');
|
|
assert.match(stdout, /mangler-type\.md/, 'skal navngi den feilende filen');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-check: rapporterer okf_version fra rot-index', () => {
|
|
const { stdout } = runCheck(REALISTIC);
|
|
assert.match(stdout, /okf_version:\s*kb-layout-2026-06/, 'skal ekko okf_version for menneskelig sammenligning');
|
|
});
|
|
|
|
// --- okf-check --strict-ingest (Step 8): lukket vokab + lenke-allow-liste ---
|
|
|
|
test('okf-check --strict-ingest: ren ingestion-bundle (vokab-type + trygg on-disk relasjon) -> exit 0', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
const { status, stdout } = runCheck(dir, '--strict-ingest');
|
|
assert.equal(status, 0, `ren bundle skal gi exit 0:\n${stdout}`);
|
|
assert.match(stdout, /0 strict-ingest-feil/, 'skal rapportere null strict-feil');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-check --strict-ingest: type utenfor vokabular -> exit 1 + navngir filen', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'rar.md'),
|
|
'---\ntype: Tilfeldig\ntitle: Rar\ndescription: x\n---\n# Rar\n',
|
|
);
|
|
const { status, stdout } = runCheck(dir, '--strict-ingest');
|
|
assert.equal(status, 1, 'out-of-vocab type skal gi exit 1');
|
|
assert.match(stdout, /rar\.md: type .* utenfor ingestion-vokabular/, 'skal navngi feilen');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-check --strict-ingest: usikker lenke (escape ut av bundle) -> exit 1', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'ond.md'),
|
|
'---\ntype: Notat\ntitle: Ond\ndescription: x\n---\n# Ond\n\n- [exfil](../../../etc/passwd)\n',
|
|
);
|
|
const { status, stdout } = runCheck(dir, '--strict-ingest');
|
|
assert.equal(status, 1, 'utrygg lenke skal gi exit 1');
|
|
assert.match(stdout, /utrygg lenke/, 'skal rapportere utrygg lenke');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-check --strict-ingest: dangling bundle-lenke (trygg form, mangler on-disk) -> exit 1', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'henger.md'),
|
|
'---\ntype: Notat\ntitle: Henger\ndescription: x\n---\n# Henger\n\n'
|
|
+ '- [Mangler](/strategisk-kontekst/finnes-ikke.md)\n',
|
|
);
|
|
const { status, stdout } = runCheck(dir, '--strict-ingest');
|
|
assert.equal(status, 1, 'dangling lenke skal gi exit 1');
|
|
assert.match(stdout, /dangling lenke/, 'skal rapportere dangling lenke');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-check --strict-ingest: lenke-baerende title -> exit 1', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'tittel.md'),
|
|
'---\ntype: Notat\ntitle: "[Klikk her](http://evil.example)"\ndescription: x\n---\n# T\n',
|
|
);
|
|
const { status, stdout } = runCheck(dir, '--strict-ingest');
|
|
assert.equal(status, 1, 'lenke-baerende title skal gi exit 1');
|
|
assert.match(stdout, /lenke-baerende title/, 'skal rapportere lenke-baerende title');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// --- walk-eksklusjon (Step 8): drop-zone + dot-kataloger skannes aldri ---
|
|
|
|
test('okf-check: raa filer i innboks/ og .cache/ ignoreres av walk (ingen falsk exit 1)', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
buildCleanIngest(dir);
|
|
mkdirSync(join(dir, 'innboks'), { recursive: true });
|
|
mkdirSync(join(dir, '.cache'), { recursive: true });
|
|
// Raa filer UTEN type -- ville gitt exit 1 hvis walk ikke ekskluderte dem.
|
|
writeFileSync(join(dir, 'innboks', 'raa.md'), '# Raa innboks-fil uten frontmatter\n');
|
|
writeFileSync(join(dir, '.cache', 'c.md'), '# Cache uten type\n');
|
|
const { status, stdout } = runCheck(dir);
|
|
assert.equal(status, 0, `drop-zone/dot-filer skal ignoreres:\n${stdout}`);
|
|
assert.match(stdout, /0 filer uten type:/, 'walk skal ikke telle drop-zone-filer');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
// --- okf-index herding (Step 9): saner title/desc + skip innboks/dot ---
|
|
|
|
test('okf-index: tittel/beskrivelse med ]/) + lenke saneres -> 2x byte-identisk + round-trip-trygg', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
mkdirSync(join(dir, 'dokumenter'), { recursive: true });
|
|
writeFileSync(join(dir, 'index.md'), '# Bundle\n\nokf_version: kb-layout-2026-06\n');
|
|
writeFileSync(
|
|
join(dir, 'dokumenter', 'kr.md'),
|
|
'---\ntype: OKR\ntitle: "KR1 [resultat] (maal) [lenke](http://x)"\n'
|
|
+ 'description: "Status (delvis) [ref](http://y)"\n---\n# KR\n',
|
|
);
|
|
generateIndexes(dir);
|
|
const run1 = snapshotIndexes(dir);
|
|
generateIndexes(dir);
|
|
const run2 = snapshotIndexes(dir);
|
|
assert.equal(run1, run2, 'generateIndexes skal vaere byte-idempotent');
|
|
const idx = readFileSync(join(dir, 'dokumenter', 'index.md'), 'utf8');
|
|
const entry = idx.split('\n').find((l) => l.startsWith('* '));
|
|
assert.ok(entry, 'kr.md skal ha en entry');
|
|
assert.match(entry, /^\* \[[^\]]*\]\([^)]+\)/, 'entry skal vaere round-trip-trygg OKF-form');
|
|
assert.ok(!entry.includes('http'), 'injisert lenke skal vaere noytralisert');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('okf-index: innboks/ + dot-katalog -> ingen egen index.md OG ikke listet i rot-index', () => {
|
|
const dir = tmpRoot();
|
|
try {
|
|
cpSync(REALISTIC, dir, { recursive: true });
|
|
mkdirSync(join(dir, 'innboks'), { recursive: true });
|
|
mkdirSync(join(dir, '.cache'), { recursive: true });
|
|
writeFileSync(join(dir, 'innboks', 'raa.md'), '# Raa\n');
|
|
writeFileSync(join(dir, '.cache', 'c.md'), '# Cache\n');
|
|
generateIndexes(dir);
|
|
assert.ok(!existsSync(join(dir, 'innboks', 'index.md')), 'innboks/ skal ikke faa index.md');
|
|
assert.ok(!existsSync(join(dir, '.cache', 'index.md')), 'dot-katalog skal ikke faa index.md');
|
|
const root = readFileSync(join(dir, 'index.md'), 'utf8');
|
|
assert.ok(!root.includes('innboks/index.md'), 'rot-index skal ikke liste innboks/ som peker');
|
|
assert.ok(!root.includes('.cache/index.md'), 'rot-index skal ikke liste dot-katalog som peker');
|
|
} finally {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
});
|