npm - @vmz/test - Versions diffs - 0.0.1 → 0.0.3 - Mend

@vmz/test 0.0.1 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/dist/logic.js ADDED Viewed

@@ -0,0 +1,377 @@
+/**
+ * Logic-mode host — headless document (linkedom), same Direct __vmzCreate as production.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import { resolveChunkArtifacts } from './compile.js';
+const require = createRequire(import.meta.url);
+function loadLinkedom() {
+    try {
+        return require('linkedom');
+    }
+    catch {
+        throw new Error('linkedom not found (add dependency on @vmz/test)');
+    }
+}
+export function installHeadlessDocument() {
+    const { parseHTML } = loadLinkedom();
+    const { window } = parseHTML('<!DOCTYPE html><html><body><div id="app"></div></body></html>');
+    globalThis.window = window;
+    globalThis.document = window.document;
+    globalThis.HTMLElement = window.HTMLElement;
+    globalThis.Node = window.Node;
+    globalThis.DocumentFragment = window.DocumentFragment;
+    globalThis.Text = window.Text;
+    globalThis.Comment = window.Comment;
+    return window.document;
+}
+export async function createLogicHost(opts) {
+    const arts = resolveChunkArtifacts(opts.outDir, opts.chunkId);
+    if (!arts.clientPath) {
+        throw new Error(`missing ${opts.chunkId}.client.js under ${opts.outDir}`);
+    }
+    const document = installHeadlessDocument();
+    const app = document.getElementById('app');
+    if (!app)
+        throw new Error('headless #app missing');
+    const dom = await import(pathToFileURL(path.join(opts.outDir, 'vmz-dom.js')).href);
+    const Component = (await import(pathToFileURL(arts.clientPath).href)).default;
+    if (!Component?.__vmzDirect || typeof Component.__vmzCreate !== 'function') {
+        throw new Error('logic host requires Direct __vmzCreate (rebuild with current compiler)');
+    }
+    if (opts.components && typeof dom.registerComponents === 'function') {
+        const map = {};
+        for (const [name, chunk] of Object.entries(opts.components)) {
+            const cArts = resolveChunkArtifacts(opts.outDir, chunk);
+            if (!cArts.clientPath)
+                throw new Error(`registerComponents: missing ${chunk}.client.js`);
+            map[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
+        }
+        dom.registerComponents(map);
+    }
+    if (typeof dom.__vmzPrecisionEnable === 'function') {
+        dom.__vmzPrecisionEnable(true);
+    }
+    const host = {
+        document,
+        app,
+        dom,
+        Component,
+        inst: null,
+        lastPrecision: null,
+        async mount(props = {}) {
+            let createHits = 0;
+            const orig = host.Component.__vmzCreate;
+            host.Component.__vmzCreate = function (api) {
+                createHits += 1;
+                return orig.call(this, api);
+            };
+            host.inst = await host.dom.mount(host.Component, host.app, props);
+            host.Component.__vmzCreate = orig;
+            if (createHits !== 1) {
+                throw new Error(`mount must call __vmzCreate once, got ${createHits}`);
+            }
+        },
+        click(selector = 'button') {
+            if (!host.inst)
+                throw new Error('click before mount');
+            const el = host.app.querySelector(selector);
+            if (!el)
+                throw new Error(`click: no element for ${JSON.stringify(selector)}`);
+            el.click();
+        },
+        write(field, value) {
+            if (!host.inst)
+                throw new Error('write before mount');
+            host.inst[field] = value;
+        },
+        async flush() {
+            if (!host.inst)
+                throw new Error('flush before mount');
+            await host.dom.flushPending(host.inst);
+        },
+        destroy() {
+            if (!host.inst)
+                throw new Error('destroy before mount');
+            host.dom.destroy(host.inst);
+        },
+        precisionReset() {
+            if (typeof host.dom.__vmzPrecisionReset === 'function')
+                host.dom.__vmzPrecisionReset();
+        },
+        precisionSnapshot() {
+            if (typeof host.dom.__vmzPrecisionSnapshot === 'function') {
+                host.lastPrecision = host.dom.__vmzPrecisionSnapshot();
+            }
+        },
+    };
+    return host;
+}
+function runOneAssertion(a, host, fail) {
+    const kind = String(a.kind || '');
+    const expect = a.expect && typeof a.expect === 'object' ? a.expect : {};
+    if (kind === 'text' || (kind === 'assert' && String(a.assertion || 'text') === 'text')) {
+        const text = host.app.textContent ?? '';
+        if (expect.equals != null && text !== String(expect.equals)) {
+            fail(`text equals want ${JSON.stringify(expect.equals)}, got ${JSON.stringify(text)}`);
+        }
+        if (expect.contains != null && !text.includes(String(expect.contains))) {
+            fail(`text contains want ${JSON.stringify(expect.contains)}, got ${JSON.stringify(text)}`);
+        }
+        if (expect.notContains != null && text.includes(String(expect.notContains))) {
+            fail(`text notContains want absent ${JSON.stringify(expect.notContains)}, got ${JSON.stringify(text)}`);
+        }
+        return;
+    }
+    if (kind === 'state') {
+        if (!host.inst) {
+            fail('state assertion before mount');
+            return;
+        }
+        for (const [k, v] of Object.entries(expect)) {
+            if (host.inst[k] !== v) {
+                fail(`state.${k} want ${JSON.stringify(v)}, got ${JSON.stringify(host.inst[k])}`);
+            }
+        }
+        return;
+    }
+    if (kind === 'precision') {
+        host.precisionSnapshot();
+        const snap = host.lastPrecision || {};
+        if (expect.minWrites != null && Number(snap.writes || 0) < Number(expect.minWrites)) {
+            fail(`precision.writes want >= ${expect.minWrites}, got ${snap.writes}`);
+        }
+        if (expect.maxWrites != null && Number(snap.writes || 0) > Number(expect.maxWrites)) {
+            fail(`precision.writes want <= ${expect.maxWrites}, got ${snap.writes}`);
+        }
+        if (expect.maxBindingEvals != null && Number(snap.bindingEvals || 0) > Number(expect.maxBindingEvals)) {
+            fail(`precision.bindingEvals want <= ${expect.maxBindingEvals}, got ${snap.bindingEvals}`);
+        }
+        if (expect.maxPatchExecs != null && Number(snap.patchExecs || 0) > Number(expect.maxPatchExecs)) {
+            fail(`precision.patchExecs want <= ${expect.maxPatchExecs}, got ${snap.patchExecs}`);
+        }
+        if (expect.patchesIncludeDep != null) {
+            const dep = String(expect.patchesIncludeDep);
+            const map = snap.patchesByDep || {};
+            if (!map[dep]) {
+                fail(`precision.patchesByDep missing ${dep}: ${JSON.stringify(map)}`);
+            }
+        }
+        if (expect.writesIncludeRoot != null) {
+            const rootKey = String(expect.writesIncludeRoot);
+            const map = snap.writesByRoot || {};
+            if (!map[rootKey]) {
+                fail(`precision.writesByRoot missing ${rootKey}: ${JSON.stringify(map)}`);
+            }
+        }
+        if (expect.patchesIncludeBinding != null) {
+            const bid = String(expect.patchesIncludeBinding);
+            const map = snap.patchesByBinding || {};
+            if (!map[bid]) {
+                fail(`precision.patchesByBinding missing ${bid}: ${JSON.stringify(map)}`);
+            }
+        }
+        if (expect.bindingEvalsIncludeBinding != null) {
+            const bid = String(expect.bindingEvalsIncludeBinding);
+            const map = snap.bindingEvalsByBinding || {};
+            if (!map[bid]) {
+                fail(`precision.bindingEvalsByBinding missing ${bid}: ${JSON.stringify(map)}`);
+            }
+        }
+        if (expect.domCreates === 0 || expect.domCreates === false) {
+            if (Number(snap.domCreates || 0) !== 0) {
+                fail(`precision.domCreates want 0 after action window, got ${snap.domCreates}`);
+            }
+        }
+        return;
+    }
+    if (kind === 'destroyed') {
+        if (!host.inst) {
+            fail('destroyed assertion before mount');
+            return;
+        }
+        const want = expect.value !== false;
+        if (Boolean(host.inst.__vmzDestroyed) !== want) {
+            fail(`__vmzDestroyed want ${want}, got ${host.inst.__vmzDestroyed}`);
+        }
+        return;
+    }
+    if (kind === 'exists') {
+        const sel = String(expect.selector || '');
+        if (!sel || !host.app.querySelector(sel)) {
+            fail(`exists: missing ${JSON.stringify(sel)}`);
+        }
+        return;
+    }
+    if (kind === 'domKeys') {
+        const attr = String(expect.attr || 'data-vmz-key');
+        const keys = [...host.app.querySelectorAll(`[${attr}]`)].map((el) => el.getAttribute(attr));
+        if (Array.isArray(expect.includes)) {
+            for (const k of expect.includes) {
+                if (!keys.includes(String(k)))
+                    fail(`domKeys missing ${k}: ${JSON.stringify(keys)}`);
+            }
+        }
+        if (Array.isArray(expect.excludes)) {
+            for (const k of expect.excludes) {
+                if (keys.includes(String(k)))
+                    fail(`domKeys should exclude ${k}: ${JSON.stringify(keys)}`);
+            }
+        }
+        return;
+    }
+    if (kind === 'childDestroyed') {
+        const want = expect.value !== false;
+        const child = host._capturedChild;
+        if (!child) {
+            fail('childDestroyed: no captured child (use capture_child action)');
+            return;
+        }
+        if (Boolean(child.__vmzDestroyed) !== want) {
+            fail(`child __vmzDestroyed want ${want}, got ${child.__vmzDestroyed}`);
+        }
+        return;
+    }
+    if (kind === 'graph' || kind === 'plan' || kind === 'diagnostic' || kind === 'view') {
+        return;
+    }
+    if (kind === 'assert') {
+        // assertion kind nested: { kind: "assert", assertion: "text", expect: {...} }
+        const nested = { ...a, kind: String(a.assertion || 'text') };
+        runOneAssertion(nested, host, fail);
+        return;
+    }
+    fail(`unknown assertion kind ${JSON.stringify(kind)}`);
+}
+export async function runLogicManifest(manifest, ctx) {
+    const diagnostics = [];
+    const program = manifest.program && typeof manifest.program === 'object' ? manifest.program : {};
+    const chunkId = String(program.chunkId || '');
+    const programId = chunkId || null;
+    const fail = (message, extra = {}) => {
+        diagnostics.push({ severity: 'error', message, ...extra });
+    };
+    if (!chunkId) {
+        fail('program.chunkId missing');
+        return { status: 'error', diagnostics, planId: null, programId: null };
+    }
+    let planId = null;
+    const arts = resolveChunkArtifacts(ctx.outDir, chunkId);
+    if (arts.programPath) {
+        try {
+            const prog = JSON.parse(fs.readFileSync(arts.programPath, 'utf8'));
+            const unit = prog.units?.[0];
+            if (unit?.plan?.schema)
+                planId = String(unit.plan.schema);
+        }
+        catch {
+            /* optional */
+        }
+    }
+    const components = program.components && typeof program.components === 'object' ? program.components : undefined;
+    let host;
+    try {
+        host = await createLogicHost({ outDir: ctx.outDir, chunkId, components });
+    }
+    catch (e) {
+        fail(e instanceof Error ? e.message : String(e));
+        return { status: 'error', diagnostics, planId, programId };
+    }
+    const actions = Array.isArray(manifest.actions) ? manifest.actions : [];
+    for (const raw of actions) {
+        const a = raw && typeof raw === 'object' ? raw : {};
+        const kind = String(a.kind || '');
+        try {
+            if (kind === 'mount') {
+                const props = a.props && typeof a.props === 'object' ? a.props : {};
+                await host.mount(props);
+                continue;
+            }
+            if (kind === 'click') {
+                host.click(typeof a.selector === 'string' ? a.selector : 'button');
+                continue;
+            }
+            if (kind === 'write') {
+                const field = String(a.field || '');
+                if (!field) {
+                    fail('write missing field');
+                    continue;
+                }
+                host.write(field, a.value);
+                continue;
+            }
+            if (kind === 'flush') {
+                await host.flush();
+                continue;
+            }
+            if (kind === 'destroy') {
+                host.destroy();
+                continue;
+            }
+            if (kind === 'precision_reset') {
+                host.precisionReset();
+                continue;
+            }
+            if (kind === 'precision_snapshot') {
+                host.precisionSnapshot();
+                continue;
+            }
+            if (kind === 'register_components') {
+                const map = a.components && typeof a.components === 'object' ? a.components : {};
+                const loaded = {};
+                for (const [name, chunk] of Object.entries(map)) {
+                    const cArts = resolveChunkArtifacts(ctx.outDir, chunk);
+                    if (!cArts.clientPath) {
+                        fail(`register_components: missing ${chunk}.client.js`);
+                        continue;
+                    }
+                    loaded[name] = (await import(pathToFileURL(cArts.clientPath).href)).default;
+                }
+                host.dom.registerComponents(loaded);
+                continue;
+            }
+            if (kind === 'stub_onMount') {
+                if (!host.inst && !host.Component) {
+                    fail('stub_onMount before component load');
+                    continue;
+                }
+                const Comp = host.Component;
+                Comp.prototype.onMount = async function () { };
+                continue;
+            }
+            if (kind === 'capture_child') {
+                const sel = String(a.selector || '');
+                const el = host.app.querySelector(sel);
+                if (!el?.__vmzInst) {
+                    fail(`capture_child: no inst for ${sel}`);
+                    continue;
+                }
+                host._capturedChild = el.__vmzInst;
+                continue;
+            }
+            if (kind === 'assert') {
+                runOneAssertion(a, host, fail);
+                continue;
+            }
+            fail(`unknown action kind ${JSON.stringify(kind)}`);
+        }
+        catch (e) {
+            fail(`action ${kind}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    host.precisionSnapshot();
+    const assertions = Array.isArray(manifest.assertions) ? manifest.assertions : [];
+    for (const raw of assertions) {
+        const a = raw && typeof raw === 'object' ? raw : {};
+        runOneAssertion(a, host, fail);
+    }
+    const failed = diagnostics.some((d) => d.severity === 'error');
+    return {
+        status: failed ? 'failed' : 'passed',
+        diagnostics,
+        planId,
+        programId,
+    };
+}

package/dist/protocol.d.ts ADDED Viewed

@@ -0,0 +1,53 @@
+/**
+ * VMZ native test protocol — validators + report builders.
+ * Schema ids live in `@vmz/protocol` (mirrors Rust `vmz-protocol`).
+ */
+export { EXECUTION_PLAN_REF_SCHEMA, PLAN_SCHEMA, TEST_ACTION_SCHEMA, TEST_ASSERTION_SCHEMA, TEST_MANIFEST_SCHEMA, TEST_PROTOCOL, TEST_REPORT_SCHEMA, testCatalog, } from '@vmz/protocol';
+export type TestMode = 'compile' | 'logic' | 'browser' | 'ssr' | 'resume' | 'deployment' | 'all';
+export declare const TEST_MODES: readonly TestMode[];
+export declare function isTestMode(v: unknown): v is TestMode;
+/** Normalize `--mode` flag: `compile,logic` or `all`. */
+export declare function parseModes(raw: string | boolean | undefined | null): TestMode[];
+export type ManifestValidation = {
+    ok: true;
+    manifest: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+/** Validate a discovered manifest object (narrow checks). */
+export declare function validateManifest(raw: unknown, file: string): ManifestValidation;
+export type TestReportEntryInput = {
+    testId: string;
+    file: string;
+    modes: string[];
+    programId?: string | null;
+    planId?: string | null;
+    status: string;
+    diagnostics?: unknown[];
+};
+export declare function buildTestReport(input: {
+    project: string;
+    modes: TestMode[];
+    tests: TestReportEntryInput[];
+    status?: string;
+}): {
+    schema: string;
+    status: string;
+    project: string;
+    modes: TestMode[];
+    generatedAt: string;
+    tests: {
+        testId: string;
+        file: string;
+        modes: string[];
+        programId: string | null;
+        planId: string | null;
+        status: string;
+        diagnostics: unknown[];
+        trace: null;
+        snapshots: null;
+        coverage: null;
+        unknownReasons: string[];
+    }[];
+};

package/dist/protocol.js ADDED Viewed

@@ -0,0 +1,99 @@
+/**
+ * VMZ native test protocol — validators + report builders.
+ * Schema ids live in `@vmz/protocol` (mirrors Rust `vmz-protocol`).
+ */
+import { EXECUTION_PLAN_REF_SCHEMA, PLAN_SCHEMA, TEST_MANIFEST_SCHEMA, TEST_REPORT_SCHEMA } from '@vmz/protocol';
+export { EXECUTION_PLAN_REF_SCHEMA, PLAN_SCHEMA, TEST_ACTION_SCHEMA, TEST_ASSERTION_SCHEMA, TEST_MANIFEST_SCHEMA, TEST_PROTOCOL, TEST_REPORT_SCHEMA, testCatalog, } from '@vmz/protocol';
+export const TEST_MODES = Object.freeze(['compile', 'logic', 'browser', 'ssr', 'resume', 'deployment', 'all']);
+export function isTestMode(v) {
+    return typeof v === 'string' && TEST_MODES.includes(v);
+}
+/** Normalize `--mode` flag: `compile,logic` or `all`. */
+export function parseModes(raw) {
+    if (raw == null || raw === true || raw === '')
+        return ['all'];
+    const parts = String(raw)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (parts.length === 0)
+        return ['all'];
+    for (const p of parts) {
+        if (!isTestMode(p)) {
+            throw new Error(`unknown test mode \`${p}\` (want ${TEST_MODES.join('|')})`);
+        }
+    }
+    return parts;
+}
+/** Validate a discovered manifest object (narrow checks). */
+export function validateManifest(raw, file) {
+    if (!raw || typeof raw !== 'object') {
+        return { ok: false, error: `${file}: manifest must be an object` };
+    }
+    const m = raw;
+    if (m.schema !== TEST_MANIFEST_SCHEMA) {
+        return {
+            ok: false,
+            error: `${file}: schema want ${TEST_MANIFEST_SCHEMA}, got ${JSON.stringify(m.schema)}`,
+        };
+    }
+    if (typeof m.id !== 'string' || !m.id) {
+        return { ok: false, error: `${file}: missing string id` };
+    }
+    if (!Array.isArray(m.modes) || m.modes.length === 0) {
+        return { ok: false, error: `${file}: modes must be a non-empty array` };
+    }
+    for (const mode of m.modes) {
+        if (!isTestMode(mode) || mode === 'all') {
+            return { ok: false, error: `${file}: invalid mode ${JSON.stringify(mode)}` };
+        }
+    }
+    if (!m.program || typeof m.program !== 'object') {
+        return { ok: false, error: `${file}: missing program ref object` };
+    }
+    const program = m.program;
+    if (typeof program.chunkId !== 'string' || !program.chunkId) {
+        return { ok: false, error: `${file}: program.chunkId required` };
+    }
+    if (m.plan != null) {
+        if (typeof m.plan !== 'object') {
+            return { ok: false, error: `${file}: plan must be an object when present` };
+        }
+        const plan = m.plan;
+        if (plan.schema != null && plan.schema !== PLAN_SCHEMA && plan.schema !== EXECUTION_PLAN_REF_SCHEMA) {
+            return { ok: false, error: `${file}: plan.schema unexpected ${JSON.stringify(plan.schema)}` };
+        }
+    }
+    if (m.actions != null && !Array.isArray(m.actions)) {
+        return { ok: false, error: `${file}: actions must be an array` };
+    }
+    if (m.assertions != null && !Array.isArray(m.assertions)) {
+        return { ok: false, error: `${file}: assertions must be an array` };
+    }
+    return { ok: true, manifest: m };
+}
+export function buildTestReport(input) {
+    const tests = input.tests.map((t) => ({
+        testId: t.testId,
+        file: t.file,
+        modes: t.modes,
+        programId: t.programId ?? null,
+        planId: t.planId ?? null,
+        status: t.status,
+        diagnostics: t.diagnostics ?? [],
+        trace: null,
+        snapshots: null,
+        coverage: null,
+        unknownReasons: [],
+    }));
+    const failed = tests.some((t) => t.status === 'failed' || t.status === 'error');
+    const status = input.status ?? (failed ? 'failed' : tests.length === 0 ? 'empty' : 'listed');
+    return {
+        schema: TEST_REPORT_SCHEMA,
+        status,
+        project: input.project,
+        modes: input.modes,
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}

package/dist/resume.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+/**
+ * Resume host for `vmz test --mode resume` (/ first slice).
+ * SSR shell → resume adopt → event patch; onMount must not run.
+ */
+type Diag = {
+    severity: string;
+    message: string;
+    [k: string]: unknown;
+};
+export type ResumeResult = {
+    status: 'passed' | 'failed' | 'error';
+    diagnostics: Diag[];
+    planId: string | null;
+    programId: string | null;
+};
+export declare function runResumeManifest(manifest: Record<string, unknown>, ctx: {
+    outDir: string;
+}): Promise<ResumeResult>;
+export {};