test.govlab/context/core/validators/algorithm.reason.validator.test.ts
test.govlab/context/core/validators/algorithm.reason.validator.test.ts is a file in Codebase Testing. 214 lines of code and 0 definitions.
import type { Contract, DomainTier } from "@govlab/context/types/algorithm.types.ts";
import { DOMAIN_TIER_VALUES } from "@govlab/context/configuration/constants/algorithm.constants.ts";
import { asClosed } from "@govlab/context/core/normalizers/field.normalizer.ts";
import assert from "node:assert/strict";
import { createGovlabContext } from "@govlab/context";
import { reasonNativeIssuesOf } from "@govlab/context/core/validators/algorithm.reason.validator.ts";
import { test } from "vitest";
interface FakeOver {
algo?: readonly Contract[];
algoIds?: Set<string>;
axes?: Set<string>;
mathTypes?: Record<string, { yieldsShape: string }>;
stages?: { axis: string; id: string }[];
}
const FIXTURE_TIERS: Readonly<Record<string, DomainTier>> = {
"Architectural Clusters": "exempt",
architecture: "leaf",
pag: "process",
};
const makeContract = (over: Partial<Contract>): Contract => ({
composes: [],
domain: "",
flow: [],
force: [],
id: "",
intent: "",
invariant: "",
productions: [],
tier: FIXTURE_TIERS[over.domain ?? ""] ?? "exempt",
title: "",
...over,
});
const fakeFaces = (over: FakeOver): Parameters<typeof reasonNativeIssuesOf>[0] => ({
algo: {
all: () => over.algo ?? [],
get: (id: string) => ((over.algoIds ?? new Set<string>()).has(id) ? { id } : null),
},
reason: {
axis: (id: string) => ((over.axes ?? new Set<string>()).has(id) ? { id } : null),
derivationLoop: () => ({ stages: over.stages ?? [] }),
mathType: (id: string) => over.mathTypes?.[id] ?? null,
},
});
const REASON_VOCAB = {
axes: new Set(["evaluative", "substrate"]),
mathTypes: { logic: { yieldsShape: "boolean" }, optimization: { yieldsShape: "boolean | ranking" } },
stages: [
{ axis: "evaluative", id: "verify" },
{ axis: "substrate", id: "constrain" },
],
};
const VALID_PROCESS = {
axis: "evaluative",
domain: "pag",
id: "ok",
mathType: "logic",
stage: "verify",
yields: "boolean",
};
const LOOP_GROUNDED = {
derivationMap: [{ record: "r", stage: "verify" }],
domain: "pag",
grounds: ["reasoning:derivation-loop"],
mathType: "logic",
yields: "boolean",
};
const reasonNativeOf = (
contracts: Partial<Contract>[],
extra: Partial<FakeOver> = {},
): ReturnType<typeof reasonNativeIssuesOf> =>
reasonNativeIssuesOf(fakeFaces({ ...REASON_VOCAB, algo: contracts.map(makeContract), ...extra }));
const withRecord = { algoIds: new Set(["r"]) };
test("reasonNativeIssuesOf reports a stage that is not a loop stage", () => {
const issues = reasonNativeOf([{ domain: "pag", id: "c1", stage: "ghost" }]);
assert.deepEqual(issues.invalidStages, [{ id: "c1", stage: "ghost" }]);
assert.ok(issues.subtotal > 0);
});
test("reasonNativeIssuesOf passes a fully typed staged process record", () => {
const issues = reasonNativeOf([VALID_PROCESS]);
assert.deepEqual(issues.invalidStages, []);
assert.equal(issues.subtotal, 0);
});
test("reasonNativeIssuesOf reports an axis that resolves to no reason axis", () => {
const issues = reasonNativeOf([{ axis: "nope", domain: "pag", id: "c1" }]);
assert.deepEqual(issues.invalidAxes, [{ axis: "nope", id: "c1" }]);
});
test("reasonNativeIssuesOf reports a mathType that resolves to nothing", () => {
const issues = reasonNativeOf([{ domain: "pag", id: "c1", mathType: "nope" }]);
assert.deepEqual(issues.invalidMathTypes, [{ id: "c1", mathType: "nope" }]);
});
test("reasonNativeIssuesOf reports an axis that is not the stage's axis", () => {
const issues = reasonNativeOf([{ axis: "substrate", domain: "pag", id: "c1", stage: "verify" }]);
assert.deepEqual(issues.stageAxisMismatches, [
{ axis: "substrate", expected: "evaluative", id: "c1", stage: "verify" },
]);
});
test("reasonNativeIssuesOf reports yields carrying a token outside the shape", () => {
const issues = reasonNativeOf([{ domain: "pag", id: "c1", mathType: "logic", yields: "boolean | bogus" }]);
assert.deepEqual(issues.yieldsShapeMismatches, [
{ allowed: "boolean", id: "c1", mathType: "logic", yields: "boolean | bogus" },
]);
});
test("reasonNativeIssuesOf passes yields that is a subset of a multi-token shape", () => {
const issues = reasonNativeOf([
{ axis: "evaluative", domain: "pag", id: "c1", mathType: "optimization", stage: "verify", yields: "ranking" },
]);
assert.deepEqual(issues.yieldsShapeMismatches, []);
assert.equal(issues.subtotal, 0);
});
test("reasonNativeIssuesOf reports each derivation map defect with its reason", () => {
const ghostStage = reasonNativeOf(
[{ derivationMap: [{ record: "r", stage: "ghost" }], domain: "pag", id: "c1" }],
withRecord,
);
assert.ok(ghostStage.derivationMapDefects[0]?.reason.includes("is not a derivation-loop stage") === true);
const missing = reasonNativeOf([
{ derivationMap: [{ record: "missing", stage: "verify" }], domain: "pag", id: "c1" },
]);
assert.ok(missing.derivationMapDefects[0]?.reason.includes("resolves to no algo contract") === true);
const noVerify = reasonNativeOf(
[{ derivationMap: [{ record: "r", stage: "constrain" }], domain: "pag", id: "c1" }],
withRecord,
);
assert.ok(noVerify.derivationMapDefects[0]?.reason.includes("omits mandatory-always stage(s): verify") === true);
const selfMap = reasonNativeOf([{ derivationMap: [{ record: "c1", stage: "verify" }], domain: "pag", id: "c1" }]);
assert.ok(selfMap.derivationMapDefects[0]?.reason.includes("maps to the contract itself") === true);
});
test("reasonNativeIssuesOf passes a derivation map covering verify with resolving records", () => {
const issues = reasonNativeOf(
[
{
derivationMap: [{ record: "r", stage: "verify" }],
domain: "pag",
id: "c1",
mathType: "logic",
yields: "boolean",
},
],
withRecord,
);
assert.deepEqual(issues.derivationMapDefects, []);
});
test("reasonNativeIssuesOf reports a grammar that grounds the derivation loop twice", () => {
const issues = reasonNativeOf(
[
{ ...LOOP_GROUNDED, id: "k1" },
{ ...LOOP_GROUNDED, id: "k2" },
],
withRecord,
);
assert.deepEqual(issues.duplicateLoopGroundings, [{ domain: "pag", records: ["k1", "k2"] }]);
assert.equal(issues.subtotal, 1);
});
test("reasonNativeIssuesOf passes a single non-meta derivation loop grounding", () => {
const issues = reasonNativeOf([{ ...LOOP_GROUNDED, id: "k1" }], withRecord);
assert.deepEqual(issues.duplicateLoopGroundings, []);
assert.deepEqual(issues.metaLoopGroundings, []);
assert.equal(issues.subtotal, 0);
});
test("reasonNativeIssuesOf reports a meta record that grounds the derivation loop", () => {
const issues = reasonNativeOf([{ domain: "pag", grounds: ["reasoning:derivation-loop"], id: "k1", meta: true }]);
assert.deepEqual(issues.metaLoopGroundings, ["k1"]);
assert.equal(issues.subtotal, 1);
});
test("reasonNativeIssuesOf reports a meta record named with the kernel suffix, and passes a non-meta one", () => {
const meta = reasonNativeOf([{ domain: "pag", id: "foo-kernel", meta: true }]);
assert.deepEqual(meta.metaKernelNaming, ["foo-kernel"]);
const plain = reasonNativeOf(
[
{
derivationMap: [{ record: "r", stage: "verify" }],
domain: "pag",
id: "foo-kernel",
mathType: "logic",
yields: "boolean",
},
],
withRecord,
);
assert.deepEqual(plain.metaKernelNaming, []);
assert.equal(plain.subtotal, 0);
});
test("reasonNativeIssuesOf reports a tiered record with no mathType or yields, and exempts a meta record", () => {
assert.deepEqual(reasonNativeOf([{ domain: "architecture", id: "c1" }]).untypedRecords, ["c1"]);
const meta = reasonNativeOf([{ domain: "architecture", id: "c1", meta: true }]);
assert.deepEqual(meta.untypedRecords, []);
assert.equal(meta.subtotal, 0);
});
test("reasonNativeIssuesOf demands a stage on a process record and not on a leaf record", () => {
const process = reasonNativeOf([{ domain: "pag", id: "c1", mathType: "logic", yields: "boolean" }]);
assert.deepEqual(process.unstagedProcessRecords, ["c1"]);
const leaf = reasonNativeOf([{ domain: "architecture", id: "c1", mathType: "logic", yields: "boolean" }]);
assert.deepEqual(leaf.unstagedProcessRecords, []);
assert.equal(leaf.subtotal, 0);
});
test("a domain tier outside the closed vocabulary fails the load, and every declared tier loads", () => {
for (const tier of DOMAIN_TIER_VALUES) {
assert.equal(asClosed(DOMAIN_TIER_VALUES, tier, "algo: a planted tier"), tier);
}
assert.throws(
() => asClosed(DOMAIN_TIER_VALUES, "brand-new-grammar", "algo: a planted tier"),
(error: unknown) => error instanceof Error && error.message.includes('declares "brand-new-grammar"'),
);
});
test("reasonNativeIssuesOf passes a tiered and an exempt domain", () => {
const issues = reasonNativeOf([{ domain: "Architectural Clusters", id: "c1", meta: true }, VALID_PROCESS]);
assert.equal(issues.subtotal, 0);
});
test("the bundled context resolves with no reason-native or integrity issue", () => {
const issues = createGovlabContext().validateResolution();
assert.equal(issues.reasonNative.subtotal, 0);
assert.equal(issues.integrity.subtotal, 0);
assert.equal(issues.total, 0);
});