mirror of
https://github.com/BradGroux/veritas-kanban.git
synced 2026-10-09 13:17:52 +00:00
445 lines
15 KiB
JavaScript
445 lines
15 KiB
JavaScript
/* global structuredClone */
|
|
import assert from 'node:assert/strict';
|
|
import { test } from 'node:test';
|
|
import {
|
|
contentSizes,
|
|
evidenceFailures,
|
|
geometryFailures,
|
|
modes,
|
|
requiredEntries,
|
|
requiresOverlay,
|
|
requiredOverlayParts,
|
|
packageDigest,
|
|
schema,
|
|
routes,
|
|
seededCases,
|
|
} from './contract.mjs';
|
|
import { crc32, deflateSync } from 'node:zlib';
|
|
import { screenshotSize } from './png.mjs';
|
|
import { mkdtemp, mkdir, writeFile, symlink, rm } from 'node:fs/promises';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
|
|
const commit = 'a'.repeat(40);
|
|
const digest = 'b'.repeat(64);
|
|
const now = Date.now();
|
|
test('native content sizes fit the hosted macOS runner while retaining expanded width', () => {
|
|
assert.deepEqual(contentSizes, {
|
|
normal: { width: 1700, height: 760 },
|
|
minimum: { width: 1180, height: 760 },
|
|
});
|
|
assert.equal(modes.length, 4);
|
|
assert(modes.every((mode) => mode.height === 760));
|
|
});
|
|
test('bundle identity includes web resources and rejects external symlinks', async (t) => {
|
|
const fixture = await mkdtemp(path.join(os.tmpdir(), 'native-ui-contract-'));
|
|
t.after(() => rm(fixture, { recursive: true, force: true }));
|
|
const bundle = path.join(fixture, 'candidate.app');
|
|
await mkdir(bundle);
|
|
await writeFile(path.join(bundle, 'app.asar'), 'fixed runtime');
|
|
await writeFile(path.join(bundle, 'web.js'), 'renderer one');
|
|
const before = await packageDigest(bundle);
|
|
await writeFile(path.join(bundle, 'web.js'), 'renderer two');
|
|
assert.notEqual(await packageDigest(bundle), before);
|
|
await writeFile(path.join(fixture, 'outside.js'), 'external renderer');
|
|
await symlink('../outside.js', path.join(bundle, 'external.js'));
|
|
await assert.rejects(packageDigest(bundle), /escapes bundle/);
|
|
});
|
|
function report() {
|
|
const value = {
|
|
schema,
|
|
status: 'passed',
|
|
boundary: 'packaged-macos',
|
|
commit,
|
|
packageDigest: digest,
|
|
version: '6.1.6',
|
|
dirty: false,
|
|
httpFailures: [],
|
|
identity: {
|
|
packaged: true,
|
|
platform: 'darwin',
|
|
buildIdentity: commit,
|
|
version: '6.1.6',
|
|
osVersion: '26.0',
|
|
},
|
|
completedAt: new Date(now).toISOString(),
|
|
seededFailures: seededCases.map(([id, reason]) => ({
|
|
id: `seed/${id}`,
|
|
status: 'detected',
|
|
observedFailures: [reason],
|
|
screenshot: { path: `seed--${id}.png`, sha256: digest },
|
|
})),
|
|
entries: requiredEntries.map((id) => {
|
|
const mode = modes.find((mode) => id.startsWith(`${mode.id}/`));
|
|
return {
|
|
id,
|
|
status: 'passed',
|
|
theme: mode.theme,
|
|
screenshot: { path: `${id}.png`, sha256: digest },
|
|
nativeWindow: {
|
|
bounds: { x: 0, y: 0, width: mode.width, height: mode.height },
|
|
contentBounds: { x: 0, y: 0, width: mode.width, height: mode.height },
|
|
scaleFactor: 2,
|
|
},
|
|
completionGeometry: {
|
|
rem: 16,
|
|
width: mode.width,
|
|
height: mode.height,
|
|
scrollWidth: mode.width,
|
|
scrollHeight: mode.height,
|
|
shell: { x: 0, y: 0, width: mode.width, height: mode.height },
|
|
overlays: [],
|
|
},
|
|
geometry: {
|
|
rem: 16,
|
|
primaryHeader: {
|
|
header: { x: 0, y: 0, width: 1000, height: 82, right: 1000, bottom: 82 },
|
|
title: { x: 52, y: 0, width: 200, height: 32, right: 252, bottom: 32 },
|
|
back: { x: 0, y: 2, width: 40, height: 40, right: 40, bottom: 42 },
|
|
content: { x: 0, y: 82, width: 1000, height: 500, right: 1000, bottom: 582 },
|
|
titleText: routes.find(([name]) => id.endsWith(`/route-${name}`))?.[2],
|
|
titleCount: 1,
|
|
backText: '',
|
|
boardRailControls: 0,
|
|
fontSize: 24,
|
|
lineHeight: 32,
|
|
},
|
|
width: mode.width,
|
|
height: mode.height,
|
|
scrollWidth: mode.width,
|
|
scrollHeight: mode.height,
|
|
shell: { x: 0, y: 0, width: mode.width, height: mode.height },
|
|
overlays: requiresOverlay(id)
|
|
? [
|
|
{
|
|
x: 1,
|
|
y: 1,
|
|
width: mode.width - 2,
|
|
height: mode.height - 2,
|
|
right: mode.width - 1,
|
|
bottom: mode.height - 1,
|
|
overflow: 0,
|
|
opacity: 1,
|
|
parts: requiredOverlayParts(id).map((kind) => ({
|
|
x: 2,
|
|
y: 2,
|
|
width: 100,
|
|
height: 30,
|
|
right: 102,
|
|
bottom: 32,
|
|
name: kind.includes('header')
|
|
? 'header'
|
|
: kind === 'footer'
|
|
? 'footer'
|
|
: 'body',
|
|
insetKind: kind,
|
|
visible: true,
|
|
padding:
|
|
kind === 'header'
|
|
? [10, 16, 10, 16]
|
|
: kind === 'task-body'
|
|
? [0, 0, 0, 0]
|
|
: [16, 16, 16, 16],
|
|
})),
|
|
},
|
|
]
|
|
: [],
|
|
},
|
|
};
|
|
}),
|
|
};
|
|
for (const seed of value.seededFailures) {
|
|
const state = ['seed/clipped-modal', 'seed/overlay-padding'].includes(seed.id)
|
|
? 'create-task'
|
|
: 'route-activity';
|
|
seed.geometry = structuredClone(
|
|
value.entries.find((entry) => entry.id === `light-normal/${state}`).geometry
|
|
);
|
|
if (seed.id === 'seed/shell-blank') seed.geometry.shell.height -= 100;
|
|
if (seed.id === 'seed/clipped-modal') {
|
|
const overlay = seed.geometry.overlays[0];
|
|
overlay.x += 1700;
|
|
overlay.right += 1700;
|
|
}
|
|
if (seed.id === 'seed/heading-offset') {
|
|
seed.geometry.primaryHeader.title.y += 16;
|
|
seed.geometry.primaryHeader.title.bottom += 16;
|
|
}
|
|
if (seed.id === 'seed/context-invalid-header')
|
|
seed.geometry.primaryHeader.boardRailControls = 1;
|
|
if (seed.id === 'seed/overlay-padding')
|
|
seed.geometry.overlays[0].parts[0].padding = [0, 0, 0, 0];
|
|
if (seed.id === 'seed/dead-header')
|
|
seed.behavior = {
|
|
control: 'New Task',
|
|
visibleBefore: true,
|
|
enabledBefore: true,
|
|
dialogVisibleBefore: false,
|
|
clickCompleted: true,
|
|
waitedMs: 1000,
|
|
dialogVisibleAfter: false,
|
|
};
|
|
}
|
|
return value;
|
|
}
|
|
const failures = (value) =>
|
|
evidenceFailures(value, { commit, packageDigest: digest, version: '6.1.6' }, now);
|
|
test('complete candidate-bound matrix is accepted by the structural validator', () =>
|
|
assert.deepEqual(failures(report()), []));
|
|
test('late rate limits and server failures reject otherwise passing native evidence', () => {
|
|
for (const status of [429, 500, 503]) {
|
|
for (const state of ['startup', 'light-normal/board', 'seed/dead-header', 'teardown']) {
|
|
const r = report();
|
|
r.httpFailures.push({ state, path: '/api/tasks', method: 'GET', status });
|
|
assert(
|
|
failures(r).includes(`${state}: HTTP ${status} GET /api/tasks`),
|
|
`accepted late HTTP ${status} in ${state}`
|
|
);
|
|
}
|
|
}
|
|
});
|
|
test('missing or malformed HTTP evidence fails closed', () => {
|
|
for (const httpFailures of [undefined, null, {}, [{ status: '500' }]]) {
|
|
const r = report();
|
|
r.httpFailures = httpFailures;
|
|
assert(failures(r).includes('missing or malformed native HTTP evidence'));
|
|
}
|
|
});
|
|
test('a missing optional chat session is not a server failure', () => {
|
|
const r = report();
|
|
r.httpFailures.push({
|
|
state: 'light-normal/task-chat',
|
|
path: '/api/chat/sessions/task_fixture',
|
|
method: 'GET',
|
|
status: 404,
|
|
});
|
|
assert.deepEqual(failures(r), []);
|
|
});
|
|
test('partial, duplicate and failed matrices cannot pass', () => {
|
|
for (const mutate of [
|
|
(r) => r.entries.pop(),
|
|
(r) => (r.entries[1] = r.entries[0]),
|
|
(r) => (r.entries[0].status = 'failed'),
|
|
(r) => r.seededFailures.pop(),
|
|
(r) => (r.seededFailures[0].observedFailures = []),
|
|
]) {
|
|
const r = report();
|
|
mutate(r);
|
|
assert(failures(r).length);
|
|
}
|
|
});
|
|
test('browser, dirty, stale, wrong-commit and wrong-package reports fail closed', () => {
|
|
for (const mutate of [
|
|
(r) => (r.boundary = 'browser'),
|
|
(r) => (r.identity.packaged = false),
|
|
(r) => (r.dirty = true),
|
|
(r) => (r.completedAt = '2020-01-01'),
|
|
(r) => (r.commit = 'c'.repeat(40)),
|
|
(r) => (r.identity.buildIdentity = null),
|
|
(r) => (r.packageDigest = 'c'.repeat(64)),
|
|
]) {
|
|
const r = report();
|
|
mutate(r);
|
|
assert(failures(r).length);
|
|
}
|
|
});
|
|
test('seeded shell blank space and root overflow fail', () => {
|
|
const r = report();
|
|
r.entries[0].geometry.shell.height -= 200;
|
|
assert(failures(r).some((message) => message.includes('fill viewport')));
|
|
r.entries[0].geometry.scrollHeight += 1_000;
|
|
assert(failures(r).some((message) => message.includes('shell overflow')));
|
|
});
|
|
test('seeded clipped overlay and unreachable footer fail', () => {
|
|
const g = report().entries[0].geometry;
|
|
g.overlays = [
|
|
{
|
|
x: 10,
|
|
y: 10,
|
|
right: g.width + 20,
|
|
bottom: g.height,
|
|
overflow: 0,
|
|
parts: [{ name: 'footer', visible: false, padding: [16, 16, 16, 16] }],
|
|
},
|
|
];
|
|
assert.deepEqual(geometryFailures(g), [
|
|
'inconsistent overlay footer padding',
|
|
'unmeasured overlay',
|
|
'transparent or unmeasured overlay',
|
|
'missing overlay header/body',
|
|
'clipped overlay',
|
|
'unreachable or unmeasured overlay footer',
|
|
]);
|
|
});
|
|
test('heading, Back, context-invalid controls and inconsistent route baselines fail closed', () => {
|
|
for (const mutate of [
|
|
(h) => {
|
|
h.title.y += 8;
|
|
},
|
|
(h) => {
|
|
h.back.width = 20;
|
|
},
|
|
(h) => {
|
|
h.fontSize = 12;
|
|
},
|
|
(h) => {
|
|
h.backText = 'Back';
|
|
},
|
|
(h) => {
|
|
h.boardRailControls = 1;
|
|
},
|
|
(h) => {
|
|
h.content.y += 20;
|
|
},
|
|
(h) => {
|
|
for (const key of ['header', 'title', 'back', 'content']) {
|
|
h[key].x -= 2000;
|
|
h[key].right -= 2000;
|
|
}
|
|
},
|
|
(h) => {
|
|
h.back.right = 999;
|
|
},
|
|
(h) => {
|
|
h.title.width = 1200;
|
|
h.title.right = h.title.x + 1200;
|
|
},
|
|
]) {
|
|
const r = report();
|
|
mutate(
|
|
r.entries.find((entry) => entry.id === 'light-normal/route-workflows').geometry.primaryHeader
|
|
);
|
|
assert(failures(r).length);
|
|
}
|
|
});
|
|
test('insets use the shared rem contract, including zero-padding compound bodies', () => {
|
|
const r = report();
|
|
const g = r.entries.find((entry) => entry.id === 'light-normal/create-task').geometry;
|
|
const overlay = g.overlays[0];
|
|
overlay.parts[1].padding = [0, 0, 0, 0];
|
|
assert(geometryFailures(g).includes('inconsistent overlay body padding'));
|
|
overlay.compound = true;
|
|
assert.deepEqual(geometryFailures(g), []);
|
|
overlay.parts[0].padding[1] = 4;
|
|
assert(geometryFailures(g).includes('inconsistent overlay header padding'));
|
|
});
|
|
test('claimed seed detection requires retained defective measurements and behavioral evidence', () => {
|
|
for (const seedIndex of seededCases.keys()) {
|
|
const r = report();
|
|
const seed = r.seededFailures[seedIndex];
|
|
delete seed.geometry;
|
|
assert(failures(r).some((error) => error.startsWith(seed.id)));
|
|
}
|
|
for (const seedIndex of seededCases.keys()) {
|
|
const r = report();
|
|
const seed = r.seededFailures[seedIndex];
|
|
seed.geometry = structuredClone(
|
|
r.entries.find((entry) => entry.id === 'light-normal/route-activity').geometry
|
|
);
|
|
delete seed.behavior;
|
|
assert(failures(r).some((error) => error.startsWith(seed.id)));
|
|
}
|
|
for (const mutate of [
|
|
(b) => {
|
|
b.clickCompleted = false;
|
|
},
|
|
(b) => {
|
|
b.visibleBefore = false;
|
|
},
|
|
(b) => {
|
|
b.enabledBefore = false;
|
|
},
|
|
(b) => {
|
|
b.dialogVisibleBefore = true;
|
|
},
|
|
(b) => {
|
|
b.dialogVisibleAfter = true;
|
|
},
|
|
(b) => {
|
|
b.waitedMs = 10;
|
|
},
|
|
]) {
|
|
const r = report();
|
|
mutate(r.seededFailures.find((seed) => seed.id === 'seed/dead-header').behavior);
|
|
assert(failures(r).some((error) => error.startsWith('seed/dead-header')));
|
|
}
|
|
});
|
|
test('required footer and compound scroll measurements cannot disappear', () => {
|
|
for (const [state, kind] of [
|
|
['confirmation', 'footer'],
|
|
['create-task', 'scroll'],
|
|
['settings-general', 'scroll'],
|
|
]) {
|
|
const r = report();
|
|
const overlay = r.entries.find((entry) => entry.id === `light-normal/${state}`).geometry
|
|
.overlays[0];
|
|
overlay.parts = overlay.parts.filter((part) => part.insetKind !== kind);
|
|
assert(failures(r).some((error) => error.includes(`missing required overlay ${kind}`)));
|
|
}
|
|
const g = report().entries.find((entry) => entry.id === 'light-normal/create-task').geometry;
|
|
g.overlays[0].compound = true;
|
|
g.overlays[0].parts = g.overlays[0].parts.filter((part) => part.insetKind !== 'scroll');
|
|
assert(geometryFailures(g).includes('missing compound overlay scroll'));
|
|
});
|
|
test('missing overlay measurements and invalid native bounds fail closed', () => {
|
|
for (const mutate of [
|
|
(r) => (r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays = []),
|
|
(r) => (r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays = [{ parts: [] }]),
|
|
(r) => (r.entries[0].nativeWindow.bounds = {}),
|
|
(r) => (r.entries[0].nativeWindow.scaleFactor = -2),
|
|
(r) => (r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays[0].width = 0),
|
|
(r) => (r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays[0].opacity = 0),
|
|
(r) => delete r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays[0].opacity,
|
|
(r) => delete r.entries[0].completionGeometry,
|
|
(r) => (r.entries[0].completionGeometry.shell.height -= 100),
|
|
(r) => {
|
|
const g = r.entries[0].completionGeometry;
|
|
g.width = g.scrollWidth = g.shell.width = 0;
|
|
g.height = g.scrollHeight = g.shell.height = 0;
|
|
},
|
|
(r) => delete r.entries.find((e) => requiresOverlay(e.id)).geometry.overlays[0].parts[0].width,
|
|
]) {
|
|
const r = report();
|
|
mutate(r);
|
|
assert(failures(r).length);
|
|
}
|
|
});
|
|
test('screenshots require complete, checksummed, decodable PNG data', () => {
|
|
const chunk = (type, data) => {
|
|
const value = Buffer.alloc(data.length + 12);
|
|
value.writeUInt32BE(data.length);
|
|
value.write(type, 4);
|
|
data.copy(value, 8);
|
|
value.writeUInt32BE(crc32(value.subarray(4, -4)), value.length - 4);
|
|
return value;
|
|
};
|
|
const header = Buffer.alloc(13);
|
|
header.writeUInt32BE(1, 0);
|
|
header.writeUInt32BE(1, 4);
|
|
header[8] = 8;
|
|
header[9] = 6;
|
|
const valid = Buffer.concat([
|
|
Buffer.from('89504e470d0a1a0a', 'hex'),
|
|
chunk('IHDR', header),
|
|
chunk('IDAT', deflateSync(Buffer.alloc(5))),
|
|
chunk('IEND', Buffer.alloc(0)),
|
|
]);
|
|
assert.deepEqual(screenshotSize(valid), { width: 1, height: 1 });
|
|
assert.throws(() => screenshotSize(valid.subarray(0, 24)));
|
|
assert.throws(() => screenshotSize(valid.subarray(0, -12)));
|
|
const corrupted = Buffer.from(valid);
|
|
corrupted[45] ^= 1;
|
|
assert.throws(() => screenshotSize(corrupted));
|
|
});
|
|
test('missing screenshots, dimensions and native environment cannot pass', () => {
|
|
for (const mutate of [
|
|
(r) => delete r.entries[0].screenshot,
|
|
(r) => (r.entries[0].geometry.width = 1),
|
|
(r) => delete r.entries[0].nativeWindow,
|
|
(r) => delete r.identity.osVersion,
|
|
]) {
|
|
const r = report();
|
|
mutate(r);
|
|
assert(failures(r).length);
|
|
}
|
|
});
|