Complete provisioning job detail pages and lifecycle evidence

tests/unit/provisioning-progress.test.ts

@@ -0,0 +1,111 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { readFile } from 'node:fs/promises';
+import { newFixture, type Fixture } from '../helpers/fixture.js';
+
+let fixture: Fixture;
+beforeEach(async () => {
+    vi.resetModules();
+    fixture = await newFixture([]);
+    vi.useFakeTimers({ toFake: ['Date'] });
+    vi.setSystemTime(new Date('2026-09-28T12:00:00Z'));
+});
+afterEach(async () => { await fixture.cleanup(); vi.useRealTimers(); });
+
+async function setup() {
+    const { db } = await import('../../src/lib/server/db/index.js');
+    const handle = db();
+    handle.prepare(`INSERT INTO server_deployments (id, server, action, state, stage, started_at, triggered_by)
+        VALUES ('operation', 'server', 'create', 'waiting', 'Recorded stage', '2026-09-28T12:00:00Z', 'test')`).run();
+    const { recordProgress, readProgress } = await import('../../src/lib/server/provisioning/progress.js');
+    const read = () => readProgress(handle.prepare('SELECT observation_json FROM server_deployments WHERE id = ?').get('operation') as { observation_json: string });
+    return { handle, recordProgress, read };
+}
+
+describe('provisioning evidence persistence', () => {
+    it('keeps phase duration stable and avoids semantic event spam during repeated occupancy checks', async () => {
+        const { handle, recordProgress, read } = await setup();
+        for (let players = 4; players > 0; players--) {
+            recordProgress('operation', { phase: 'eligibility', blocker: { code: 'occupied', message: `${players} players remain`, automatic: true },
+                checks: [{ key: 'occupancy', label: 'Players', source: 'telemetry', result: 'waiting', actual: players,
+                    receivedAt: new Date().toISOString() }] });
+            vi.setSystemTime(Date.now() + 15_000);
+        }
+        expect(read()).toMatchObject({ phaseStartedAt: '2026-09-28T12:00:00.000Z', observedAt: '2026-09-28T12:00:45.000Z',
+            checks: [expect.objectContaining({ actual: 1, receivedAt: '2026-09-28T12:00:45.000Z' })] });
+        expect(handle.prepare("SELECT count(*) AS count FROM server_deployment_events WHERE kind = 'blocker'").get()).toEqual({ count: 1 });
+        recordProgress('operation', { phase: 'container-action', blocker: null,
+            checkpoint: { key: 'eligibility', label: 'Eligibility checked', phase: 'eligibility' } });
+        expect(read()).toMatchObject({ phaseStartedAt: '2026-09-28T12:01:00.000Z', blocker: null });
+    });
+
+    it('replaces transient checks while retaining confirmed milestones and prior command uncertainty', async () => {
+        const { handle, recordProgress, read } = await setup();
+        recordProgress('operation', { phase: 'verify-game', command: { state: 'uncertain', message: 'Reply was lost' },
+            checkpoint: { key: 'container-action', label: 'Submission attempted', phase: 'container-action' },
+            checks: [{ key: 'container', label: 'Container', source: 'komodo', result: 'pass' },
+                { key: 'game', label: 'Game', source: 'telemetry', result: 'pass' }] });
+        vi.setSystemTime(Date.now() + 15_000);
+        recordProgress('operation', { phase: 'verify-container', checks: [{ key: 'container', label: 'Container', source: 'komodo', result: 'unknown' }] });
+        expect(read()?.checks).toHaveLength(1);
+        expect(read()?.checks[0].result).toBe('unknown');
+        expect(read()?.checkpoints).toHaveLength(1);
+        expect(read()?.command?.state).toBe('uncertain');
+        expect(handle.prepare("SELECT message FROM server_deployment_events WHERE kind = 'command'").get()).toEqual({ message: 'Reply was lost' });
+    });
+
+    it('keeps operation-owned recovery evidence after slot/server removal and does not rewrite the failed outcome', async () => {
+        const { handle, recordProgress, read } = await setup();
+        handle.prepare("UPDATE server_deployments SET state = 'failed', finished_at = '2026-09-28T12:00:00Z' WHERE id = 'operation'").run();
+        recordProgress('operation', { recovery: { state: 'held', message: 'Observing possible submission' } });
+        vi.setSystemTime(Date.now() + 30_000);
+        recordProgress('operation', { recovery: { state: 'released', message: 'Recovery verified' } });
+        recordProgress('operation', { recovery: { state: 'released', message: 'Recovery verified' } });
+        expect(read()?.recovery).toMatchObject({ state: 'released', at: '2026-09-28T12:00:30.000Z' });
+        expect(handle.prepare("SELECT state, finished_at FROM server_deployments WHERE id = 'operation'").get())
+            .toEqual({ state: 'failed', finished_at: '2026-09-28T12:00:00Z' });
+        expect(handle.prepare("SELECT count(*) AS count FROM server_deployment_events WHERE kind = 'recovery'").get()).toEqual({ count: 2 });
+    });
+
+    it('rolls back state, snapshot, and milestone events together with its caller transaction', async () => {
+        const { handle, recordProgress, read } = await setup();
+        expect(() => handle.transaction(() => {
+            handle.prepare("UPDATE server_deployments SET state = 'running' WHERE id = 'operation'").run();
+            recordProgress('operation', { phase: 'cleanup', checkpoint: { key: 'delete-deployment', label: 'Remote deletion confirmed' } });
+            throw new Error('Interrupted transaction');
+        })()).toThrow('Interrupted transaction');
+        expect(read()).toBeNull();
+        expect(handle.prepare("SELECT state FROM server_deployments WHERE id = 'operation'").get()).toEqual({ state: 'waiting' });
+        expect(handle.prepare('SELECT * FROM server_deployment_events').all()).toEqual([]);
+    });
+
+    it('treats unsupported or malformed historical snapshots as unrecorded', async () => {
+        const { readProgress } = await import('../../src/lib/server/provisioning/progress.js');
+        for (const observation_json of [null, '', '[]', '{broken', '{"version":2}', '{"version":1,"checks":"pass"}']) {
+            expect(readProgress({ observation_json })).toBeNull();
+        }
+    });
+
+    it('adds nullable evidence columns without losing historical identity, row order, or events across reopen', async () => {
+        const schema = (await readFile(new URL('../../src/lib/server/db/schema.sql', import.meta.url), 'utf8'))
+            .replace(',\n    phase_key TEXT,\n    phase_started_at TEXT,\n    observed_at TEXT,\n    observation_json TEXT', '')
+            .replace(',\n    kind TEXT,\n    phase_key TEXT,\n    details_json TEXT', '')
+            .replace("'create', 'start', 'restart', 'rebuild', 'stop', 'destroy'", "'create', 'destroy'");
+        const old = new Database(fixture.dbPath);
+        old.exec(schema);
+        old.prepare(`INSERT INTO server_deployments (rowid,id,server,server_deleted_at,action,state,stage,started_at,triggered_by)
+            VALUES (42,'legacy','server','2026-09-01','create','done','Recorded result','2026-08-01','test')`).run();
+        old.prepare("INSERT INTO server_deployment_events (id,deployment_id,created_at,message) VALUES (19,'legacy','2026-08-01','Original evidence')").run();
+        old.close();
+        const { db, closeDb } = await import('../../src/lib/server/db/index.js');
+        expect(db().prepare("SELECT rowid, server_deleted_at, observation_json FROM server_deployments WHERE id = 'legacy'").get())
+            .toEqual({ rowid: 42, server_deleted_at: '2026-09-01', observation_json: null });
+        const { recordProgress, readProgress } = await import('../../src/lib/server/provisioning/progress.js');
+        recordProgress('legacy', { recovery: { state: 'unknown', message: 'Historical slot release was not recorded' } });
+        closeDb();
+        const saved = db().prepare("SELECT observation_json FROM server_deployments WHERE id = 'legacy'").get() as { observation_json: string };
+        expect(readProgress(saved)?.recovery?.state).toBe('unknown');
+        expect(db().prepare('SELECT id, message FROM server_deployment_events WHERE id = 19').get()).toEqual({ id: 19, message: 'Original evidence' });
+        expect(db().pragma('foreign_key_check')).toEqual([]);
+    });
+});