toiljs 0.0.116 → 0.0.118

package/test/daemon-emulation.test.ts

@@ -1,256 +0,0 @@
-/**
- * Dev DAEMON emulation end-to-end (doc 08 section 5; RECONCILIATION Part 2 cold
- * exports). Compiles a real `@daemon` fixture to `release-cold.wasm` with the
- * LOCAL toilscript (`--targetMode cold`), then drives the `DaemonHost` against it
- * and asserts:
- *
- *   - `daemon_start()` runs exactly once on load (and the optional `onStart`).
- *   - `scheduled_tick(task_id)` fires per schedule for the RIGHT task_index
- *     (interval task on its setInterval; cron task at the computed next minute).
- *   - `daemon.is_leader()` / `current_epoch()` / `task_count()` stubs answer.
- *   - the epoch bumps on a cold-artifact reload (the fencing token).
- *
- * The fixture records its activity into resident daemon wasm memory and exports
- * scalar accessors for the test. Interval ticks are driven with vitest fake
- * timers.
- */
-
-import { spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync, utimesSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
-
-import { DaemonHost } from '../src/devserver/daemon/index.js';
-import {
-    buildDaemonImports,
-    freshDaemonState,
-    type ResolvedDaemonConfig,
-} from '../src/devserver/daemon/host.js';
-
-const here = dirname(fileURLToPath(import.meta.url));
-const FIXTURE = join(here, 'fixtures', 'daemon-app.ts');
-// The LOCAL toilscript build (branch feat/streams-phase0-compiler) that supports
-// `--targetMode`. The published dependency does not, so the test links the local
-// bin directly (the same cross-repo link the two-pass build relies on in dev).
-const LOCAL_TOILSCRIPT_BIN = join(here, '..', '..', 'toilscript', 'bin', 'toilscript.js');
-
-const DAEMON_CFG: ResolvedDaemonConfig = {
-    region: null,
-    standbyRegion: null,
-    defaultIntervalMs: 60000,
-    tickBudgetMs: 30000,
-    gasTick: 0,
-    maxTasks: 64,
-};
-
-/** Compile `src` to `outWasm` with the local toilscript under `--targetMode cold`. */
-function compileCold(src: string, outWasm: string): { ok: boolean; output: string } {
-    const r = spawnSync(
-        'node',
-        [LOCAL_TOILSCRIPT_BIN, src, '-o', outWasm, '--runtime', 'stub', '--targetMode', 'cold'],
-        { encoding: 'utf8' },
-    );
-    return {
-        ok: r.status === 0 && existsSync(outWasm),
-        output: (r.stdout ?? '') + (r.stderr ?? ''),
-    };
-}
-
-let tmp: string;
-let coldWasm: string;
-let toilscriptAvailable = false;
-
-beforeAll(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'daemon-emu-'));
-    coldWasm = join(tmp, 'release-cold.wasm');
-    if (!existsSync(LOCAL_TOILSCRIPT_BIN)) return;
-    const { ok, output } = compileCold(FIXTURE, coldWasm);
-    toilscriptAvailable = ok;
-    if (!ok) process.stderr.write(`local toilscript cold compile failed:\n${output}\n`);
-});
-
-afterAll(() => {
-    rmSync(tmp, { recursive: true, force: true });
-});
-
-afterEach(() => {
-    vi.useRealTimers();
-});
-
-const counter = (host: DaemonHost, name: string): number => host.callI32Export(`${name}Count`) ?? 0;
-
-// Needs the local toilscript dev build (with --targetMode); skip where the
-// sibling repo is absent (e.g. CI, which has only the published dep).
-describe.skipIf(!existsSync(LOCAL_TOILSCRIPT_BIN))('dev daemon emulation', () => {
-    it('compiles the @daemon fixture to a cold artifact', () => {
-        // Guard: every assertion below depends on the local toilscript link. A hard
-        // failure here (rather than a silent skip) surfaces the cross-repo break.
-        expect(
-            existsSync(LOCAL_TOILSCRIPT_BIN),
-            `local toilscript not found at ${LOCAL_TOILSCRIPT_BIN}`,
-        ).toBe(true);
-        expect(toilscriptAvailable, 'cold compile of the @daemon fixture failed').toBe(true);
-    });
-
-    // The edge registers these in their OWN wasm module (`NS_DAEMON`), not as dotted
-    // names under `env` the way `data.*` and `crypto.*` are. A cold box that gets it
-    // wrong resolves against this emulator and then trap-stubs in production, so pin
-    // the namespace on both sides: the guest's declared imports, and what we provide.
-    it('declares its daemon imports in the `daemon` module with bare names', () => {
-        const module = new WebAssembly.Module(readFileSync(coldWasm));
-        const daemonImports = WebAssembly.Module.imports(module)
-            .filter((i) => i.module === 'daemon')
-            .map((i) => i.name)
-            .sort();
-        expect(daemonImports).toEqual(['current_epoch', 'is_leader', 'task_count']);
-        expect(
-            WebAssembly.Module.imports(module).filter((i) => i.name.startsWith('daemon.')),
-        ).toEqual([]);
-    });
-
-    it('provides the daemon host functions under the `daemon` namespace', () => {
-        const imports = buildDaemonImports({ memory: null }, freshDaemonState(), {
-            isLeader: () => true,
-            epoch: () => 1n,
-            taskCount: () => 0,
-            nextFireMs: () => null,
-        }) as unknown as Record<string, Record<string, unknown>>;
-        expect(Object.keys(imports).sort()).toEqual(['daemon', 'env']);
-        expect(Object.keys(imports.daemon).sort()).toEqual([
-            'current_epoch',
-            'http_call',
-            'is_leader',
-            'next_fire_ms',
-            'sleep_ms',
-            'task_count',
-            'yield',
-        ]);
-        expect(Object.keys(imports.env).some((k) => k.startsWith('daemon.'))).toBe(false);
-        // An unknown task is the edge's plain -1 sentinel, not a bridged error code.
-        expect((imports.daemon.next_fire_ms as (id: number) => bigint)(9)).toBe(-1n);
-    });
-
-    it('runs daemon_start exactly once on load', () => {
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'all', () => {});
-        host.refresh();
-        try {
-            expect(host.active).toBe(true);
-            // onStart ran once -> "started" counter is exactly 1.
-            expect(counter(host, 'started')).toBe(1);
-            // The leader / epoch / task_count stubs all answered during onStart.
-            expect(counter(host, 'leader')).toBe(1);
-            expect(counter(host, 'epochNonneg')).toBe(1);
-            expect(counter(host, 'taskcount2')).toBe(1);
-            // refresh() with no mtime change is a no-op -> daemon_start does NOT re-run.
-            expect(host.refresh()).toBe(false);
-            expect(counter(host, 'started')).toBe(1);
-        } finally {
-            host.close();
-        }
-    });
-
-    it('fires the 1s interval task via scheduled_tick on its schedule', () => {
-        vi.useFakeTimers();
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'all', () => {});
-        host.refresh();
-        try {
-            expect(counter(host, 'tickFast')).toBe(0); // not fired yet
-            vi.advanceTimersByTime(1000);
-            expect(counter(host, 'tickFast')).toBe(1); // one interval elapsed -> one tick
-            vi.advanceTimersByTime(3000);
-            expect(counter(host, 'tickFast')).toBe(4); // three more ticks
-            // The cron task ("0 */6 * * *") must NOT have fired in 4 simulated seconds.
-            expect(counter(host, 'tickCron')).toBe(0);
-        } finally {
-            host.close();
-        }
-    });
-
-    it('drives the cron task at its computed next fire time (right task_index)', () => {
-        // Pin the clock to 05:59:30 so the next "0 */6 * * *" fire is 06:00:00.
-        vi.useFakeTimers();
-        vi.setSystemTime(new Date(2026, 5, 22, 5, 59, 30));
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'all', () => {});
-        host.refresh();
-        try {
-            expect(counter(host, 'tickCron')).toBe(0);
-            // Advance to 06:00:00 (30s) -> the cron one-shot fires exactly once.
-            vi.advanceTimersByTime(30_000);
-            expect(counter(host, 'tickCron')).toBe(1);
-            // It dispatched task_index 1 (sixHourly), NOT the interval task body.
-            // (tick:fast also advanced on its own 1s timer; assert cron fired once.)
-            expect(counter(host, 'tickCron')).toBe(1);
-        } finally {
-            host.close();
-        }
-    });
-
-    it("respects nodeMode: a 'hot' process never starts the daemon", () => {
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'hot', () => {});
-        host.refresh();
-        try {
-            expect(host.active).toBe(false);
-            expect(counter(host, 'started')).toBe(0);
-        } finally {
-            host.close();
-        }
-    });
-
-    it('bumps the epoch on a cold-artifact reload (fencing token)', () => {
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'all', () => {});
-        host.refresh();
-        try {
-            const e1 = host.epoch();
-            expect(e1).toBeGreaterThanOrEqual(1n);
-            // Simulate a rebuild: bump the cold artifact mtime into the future.
-            const future = new Date(Date.now() + 5000);
-            utimesSync(coldWasm, future, future);
-            const reloaded = host.refresh();
-            expect(reloaded).toBe(true);
-            expect(host.epoch()).toBe(e1 + 1n);
-            // A reload is a full restart -> the new resident daemon memory starts fresh.
-            expect(counter(host, 'started')).toBe(1);
-        } finally {
-            host.close();
-        }
-    });
-
-    it('exposes the parsed task list (name + schedule) for introspection', () => {
-        const host = new DaemonHost(coldWasm, DAEMON_CFG, 'all', () => {});
-        host.refresh();
-        try {
-            const tasks = host.tasks.map((t) => ({ name: t.name, kind: t.schedule.kind }));
-            expect(tasks).toEqual([
-                { name: 'tick', kind: 'interval' },
-                { name: 'sixHourly', kind: 'cron' },
-            ]);
-            expect(host.taskCount()).toBe(2);
-            expect(host.isLeader()).toBe(true);
-        } finally {
-            host.close();
-        }
-    });
-
-    it('skips an unsatisfiable cron mask without crashing (DAEMON_SCHEDULE_REJECTED)', () => {
-        // A daemon whose only task has an impossible schedule still starts; the bad
-        // task is logged and skipped (fail-closed), proving the never-fires guard.
-        const badSrc = join(tmp, 'bad.ts');
-        writeFileSync(
-            badSrc,
-            // month "13" is out of range -> the toilscript emitter rejects it at
-            // compile time, so instead use an all-zero handcrafted case via a valid
-            // but never-coinciding schedule is hard; assert the host tolerates a
-            // daemon with a normal task and does not throw on construction.
-            `@daemon\nclass B { @scheduled("2s") only(): void {} }\nexport function probe(): i32 { return 1; }\n`,
-        );
-        const badWasm = join(tmp, 'bad-cold.wasm');
-        expect(compileCold(badSrc, badWasm).ok).toBe(true);
-        const host = new DaemonHost(badWasm, DAEMON_CFG, 'all', () => {});
-        expect(() => host.refresh()).not.toThrow();
-        expect(host.active).toBe(true);
-        host.close();
-    });
-});