@ai-devkit/agent-manager 0.32.0 → 0.33.1

package/src/__tests__/adapters/PiAdapter.test.ts

@@ -1,458 +0,0 @@
-/**
- * Tests for PiAdapter
- */
-
-import type { MockedFunction } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-import { PiAdapter } from '../../adapters/PiAdapter.js';
-import type { ProcessInfo } from '../../adapters/AgentAdapter.js';
-import { AgentStatus } from '../../adapters/AgentAdapter.js';
-import { AgentRegistry } from '../../utils/AgentRegistry.js';
-import { listAgentProcesses, enrichProcesses, captureProcessSnapshot } from '../../utils/process.js';
-import { matchProcessesToSessions, generateAgentName } from '../../utils/matching.js';
-
-vi.mock('../../utils/process.js', async (importOriginal) => {
-    const actual = await importOriginal() as typeof import('../../utils/process.js');
-    return {
-        ...actual,
-        listAgentProcesses: vi.fn(),
-        enrichProcesses: vi.fn(),
-        captureProcessSnapshot: vi.fn(),
-    };
-});
-
-vi.mock('../../utils/matching.js', () => ({
-    matchProcessesToSessions: vi.fn(),
-    generateAgentName: vi.fn(),
-}));
-
-const mockedListAgentProcesses = listAgentProcesses as MockedFunction<typeof listAgentProcesses>;
-const mockedEnrichProcesses = enrichProcesses as MockedFunction<typeof enrichProcesses>;
-const mockedCaptureProcessSnapshot = captureProcessSnapshot as MockedFunction<typeof captureProcessSnapshot>;
-const mockedMatchProcessesToSessions = matchProcessesToSessions as MockedFunction<typeof matchProcessesToSessions>;
-const mockedGenerateAgentName = generateAgentName as MockedFunction<typeof generateAgentName>;
-
-describe('PiAdapter', () => {
-    let adapter: PiAdapter;
-    let tmpHome: string;
-    let sessionsDir: string;
-
-    beforeEach(() => {
-        tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-adapter-test-'));
-        process.env.HOME = tmpHome;
-        sessionsDir = path.join(tmpHome, '.pi', 'agent', 'sessions');
-        fs.mkdirSync(sessionsDir, { recursive: true });
-
-        adapter = new PiAdapter(new AgentRegistry(path.join(tmpHome, 'agents.json')));
-        mockedListAgentProcesses.mockReset();
-        mockedEnrichProcesses.mockReset();
-        mockedCaptureProcessSnapshot.mockReset();
-        mockedMatchProcessesToSessions.mockReset();
-        mockedGenerateAgentName.mockReset();
-
-        mockedEnrichProcesses.mockImplementation((procs) => procs);
-        // Compatibility shim for standalone adapter discovery; the manager captures once and slices by name.
-        mockedCaptureProcessSnapshot.mockImplementation(async (names) => (
-            enrichProcesses(names.flatMap((name) => listAgentProcesses(name)))
-        ));
-        mockedMatchProcessesToSessions.mockReturnValue([]);
-        mockedGenerateAgentName.mockImplementation((cwd: string, pid: number) => {
-            const folder = path.basename(cwd) || 'unknown';
-            return `${folder} (${pid})`;
-        });
-    });
-
-    afterEach(() => {
-        fs.rmSync(tmpHome, { recursive: true, force: true });
-    });
-
-    it('exposes pi type', () => {
-        expect(adapter.type).toBe('pi');
-    });
-
-    it('identifies Pi commands without matching unrelated paths', () => {
-        expect(adapter.canHandle({ pid: 1, command: 'pi', cwd: '/repo', tty: 'ttys001' })).toBe(true);
-        expect(adapter.canHandle({ pid: 2, command: '/usr/local/bin/PI --model x', cwd: '/repo', tty: 'ttys002' })).toBe(true);
-        expect(adapter.canHandle({ pid: 3, command: 'node /opt/pi/bin/pi.js', cwd: '/repo', tty: 'ttys003' })).toBe(true);
-        expect(adapter.canHandle({ pid: 4, command: 'node /repo/feature-pi-adapter/script.js', cwd: '/repo', tty: 'ttys004' })).toBe(false);
-        expect(adapter.canHandle({ pid: 5, command: 'C:\\tools\\node.exe C:\\lib\\pi.js', cwd: '/repo', tty: 'ttys005' })).toBe(true);
-    });
-
-    it('rejects foreign executables from a hand-built snapshot context', async () => {
-        const foreign: ProcessInfo = {
-            pid: 6,
-            command: 'claude --resume /Users/x/repos/pi/session.jsonl',
-            cwd: '/repo',
-            tty: 'ttys006',
-        };
-
-        expect(await adapter.detectAgents({ processes: [foreign] })).toEqual([]);
-    });
-
-    it('maps a running Pi process to the tracker session for its PID', async () => {
-        const cwd = '/repo/project-a';
-        const proc = makeProcess({ pid: 101, cwd });
-        const sessionFile = writePiSession(cwd, [
-            { type: 'session_meta', timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-101', cwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'implement Pi adapter' },
-            { role: 'assistant', timestamp: new Date().toISOString(), content: 'working on it' },
-        ]);
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 101: sessionFile }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0]).toMatchObject({
-            type: 'pi',
-            pid: 101,
-            projectPath: cwd,
-            sessionId: 'sess-101',
-            summary: 'implement Pi adapter',
-            status: AgentStatus.WAITING,
-            sessionFilePath: sessionFile,
-        });
-        expect(mockedMatchProcessesToSessions).not.toHaveBeenCalled();
-    });
-
-    it('truncates long user prompts in detected agent summaries', async () => {
-        const cwd = '/repo/project-long-summary';
-        const proc = makeProcess({ pid: 112, cwd });
-        const longPrompt = 'x'.repeat(140);
-        const sessionFile = writePiSession(cwd, [
-            { type: 'session', timestamp: '2026-06-10T08:58:20.754Z', id: 'sess-long', cwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: longPrompt },
-        ]);
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 112: sessionFile }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents[0].summary).toHaveLength(120);
-        expect(agents[0].summary.endsWith('...')).toBe(true);
-    });
-
-    it('uses the filename session id fallback and reports running when the latest message is from the user', async () => {
-        const cwd = '/repo/project-filename-fallback';
-        const proc = makeProcess({ pid: 113, cwd });
-        const sessionFile = writePiSessionWithFileName(cwd, 'plain-session.jsonl', [
-            { role: 'user', timestamp: new Date().toISOString(), content: 'still working' },
-        ]);
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 113: sessionFile }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents[0]).toMatchObject({
-            sessionId: 'plain-session',
-            summary: 'still working',
-            status: AgentStatus.RUNNING,
-        });
-    });
-
-    it('falls back to legacy matching when sessions.json is missing', async () => {
-        const cwd = '/repo/project-b';
-        const proc = makeProcess({ pid: 202, cwd });
-        const sessionFile = writePiSession(cwd, [
-            { timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-202' },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'fallback matching please' },
-        ]);
-        mockedListAgentProcesses.mockReturnValue([proc]);
-        mockedMatchProcessesToSessions.mockReturnValue([
-            {
-                process: proc,
-                session: {
-                    sessionId: 'sess-202',
-                    filePath: sessionFile,
-                    projectDir: path.dirname(sessionFile),
-                    birthtimeMs: Date.now(),
-                    resolvedCwd: cwd,
-                },
-                deltaMs: 0,
-            },
-        ]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0]).toMatchObject({
-            type: 'pi',
-            pid: 202,
-            projectPath: cwd,
-            sessionId: 'sess-202',
-            summary: 'fallback matching please',
-        });
-        expect(mockedMatchProcessesToSessions).toHaveBeenCalledWith(
-            [proc],
-            expect.arrayContaining([
-                expect.objectContaining({ filePath: sessionFile, resolvedCwd: cwd }),
-            ]),
-        );
-    });
-
-    it('ignores malformed tracker metadata and still falls back to legacy matching', async () => {
-        const cwd = '/repo/project-c';
-        const proc = makeProcess({ pid: 303, cwd });
-        const sessionFile = writePiSession(cwd, [
-            { timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-303', cwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'recover from bad tracker' },
-        ]);
-        fs.writeFileSync(path.join(tmpHome, '.pi', 'agent', 'sessions.json'), '{bad json');
-        mockedListAgentProcesses.mockReturnValue([proc]);
-        mockedMatchProcessesToSessions.mockReturnValue([
-            {
-                process: proc,
-                session: {
-                    sessionId: 'sess-303',
-                    filePath: sessionFile,
-                    projectDir: path.dirname(sessionFile),
-                    birthtimeMs: Date.now(),
-                    resolvedCwd: cwd,
-                },
-                deltaMs: 0,
-            },
-        ]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0].sessionId).toBe('sess-303');
-    });
-
-    it('falls back to legacy matching when a trusted tracker session is unparseable', async () => {
-        const cwd = '/repo/project-bad-tracker-session';
-        const proc = makeProcess({ pid: 304, cwd });
-        const badSessionFile = writePiSessionWithFileName(cwd, 'bad.jsonl', ['{not json']);
-        const fallbackSessionFile = writePiSession(cwd, [
-            { timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-304', cwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'fallback after bad tracker session' },
-        ]);
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 304: badSessionFile }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-        mockedMatchProcessesToSessions.mockReturnValue([
-            {
-                process: proc,
-                session: {
-                    sessionId: 'sess-304',
-                    filePath: fallbackSessionFile,
-                    projectDir: path.dirname(fallbackSessionFile),
-                    birthtimeMs: Date.now(),
-                    resolvedCwd: cwd,
-                },
-                deltaMs: 0,
-            },
-        ]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0]).toMatchObject({
-            sessionId: 'sess-304',
-            summary: 'fallback after bad tracker session',
-            sessionFilePath: fallbackSessionFile,
-        });
-        expect(mockedMatchProcessesToSessions).toHaveBeenCalled();
-    });
-
-    it('does not trust tracker paths outside the Pi sessions directory', async () => {
-        const cwd = '/repo/project-d';
-        const proc = makeProcess({ pid: 404, cwd });
-        const outside = path.join(tmpHome, 'outside.jsonl');
-        fs.writeFileSync(outside, JSON.stringify({ role: 'user', content: 'nope' }));
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 404: outside }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0]).toMatchObject({
-            type: 'pi',
-            pid: 404,
-            sessionId: 'pid-404',
-            summary: 'Pi process running',
-        });
-    });
-
-    it('returns a process-only agent when no session can be matched', async () => {
-        const proc = makeProcess({ pid: 505, cwd: '/repo/project-e' });
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        const agents = await adapter.detectAgents();
-
-        expect(agents).toHaveLength(1);
-        expect(agents[0]).toMatchObject({
-            type: 'pi',
-            status: AgentStatus.RUNNING,
-            pid: 505,
-            projectPath: '/repo/project-e',
-            sessionId: 'pid-505',
-            summary: 'Pi process running',
-        });
-    });
-
-    it('reads user and assistant conversation messages from JSONL', () => {
-        const cwd = '/repo/project-f';
-        const sessionFile = writePiSession(cwd, [
-            { role: 'system', timestamp: '2026-06-10T08:58:20.000Z', content: 'hidden' },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'hello pi' },
-            { type: 'assistant', timestamp: '2026-06-10T08:58:22.000Z', message: { content: 'hello human' } },
-            '{not json',
-        ]);
-
-        expect(adapter.getConversation(sessionFile)).toEqual([
-            { role: 'user', content: 'hello pi', timestamp: '2026-06-10T08:58:21.000Z' },
-            { role: 'assistant', content: 'hello human', timestamp: '2026-06-10T08:58:22.000Z' },
-        ]);
-    });
-
-    it('includes system entries only in verbose conversation mode', () => {
-        const cwd = '/repo/project-verbose';
-        const sessionFile = writePiSession(cwd, [
-            { role: 'system', timestamp: '2026-06-10T08:58:20.000Z', content: 'model changed' },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'visible' },
-        ]);
-
-        expect(adapter.getConversation(sessionFile)).toEqual([
-            { role: 'user', content: 'visible', timestamp: '2026-06-10T08:58:21.000Z' },
-        ]);
-        expect(adapter.getConversation(sessionFile, { verbose: true })).toEqual([
-            { role: 'system', content: 'model changed', timestamp: '2026-06-10T08:58:20.000Z' },
-            { role: 'user', content: 'visible', timestamp: '2026-06-10T08:58:21.000Z' },
-        ]);
-    });
-
-    it('reads real Pi message entries with nested role and text parts', async () => {
-        const cwd = '/repo/project-real';
-        const proc = makeProcess({ pid: 606, cwd });
-        const sessionFile = writePiSession(cwd, [
-            { type: 'session', version: 3, id: 'sess-real', timestamp: '2026-06-10T13:27:17.581Z', cwd },
-            { type: 'model_change', id: 'model-1', timestamp: '2026-06-10T13:27:17.655Z', modelId: 'claude-sonnet-4-6' },
-            {
-                type: 'message',
-                id: 'msg-user',
-                timestamp: '2026-06-10T13:27:37.975Z',
-                message: {
-                    role: 'user',
-                    content: [{ type: 'text', text: 'hello' }],
-                    timestamp: 1781098057974,
-                },
-            },
-            {
-                type: 'message',
-                id: 'msg-assistant',
-                timestamp: '2026-06-10T13:27:40.161Z',
-                message: {
-                    role: 'assistant',
-                    content: [{ type: 'text', text: 'Hello! How can I help you today?' }],
-                    provider: 'anthropic',
-                    model: 'claude-sonnet-4-6',
-                    timestamp: 1781098058012,
-                },
-            },
-        ]);
-        fs.writeFileSync(
-            path.join(tmpHome, '.pi', 'agent', 'sessions.json'),
-            JSON.stringify({ 606: sessionFile }),
-        );
-        mockedListAgentProcesses.mockReturnValue([proc]);
-
-        expect(adapter.getConversation(sessionFile)).toEqual([
-            { role: 'user', content: 'hello', timestamp: '2026-06-10T13:27:37.975Z' },
-            { role: 'assistant', content: 'Hello! How can I help you today?', timestamp: '2026-06-10T13:27:40.161Z' },
-        ]);
-
-        const agents = await adapter.detectAgents();
-        expect(agents[0]).toMatchObject({
-            sessionId: 'sess-real',
-            summary: 'hello',
-            lastActive: new Date('2026-06-10T13:27:40.161Z'),
-        });
-    });
-
-    it('lists historical sessions and applies cwd filtering', async () => {
-        const matchingCwd = '/repo/project-g';
-        const otherCwd = '/repo/project-h';
-        const matchingSession = writePiSession(matchingCwd, [
-            { timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-g', cwd: matchingCwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'first matching message' },
-        ]);
-        writePiSession(otherCwd, [
-            { timestamp: '2026-06-10T08:58:20.754Z', sessionId: 'sess-h', cwd: otherCwd },
-            { role: 'user', timestamp: '2026-06-10T08:58:21.000Z', content: 'other message' },
-        ]);
-
-        const sessions = await adapter.listSessions({ cwd: matchingCwd });
-
-        expect(sessions).toEqual([
-            expect.objectContaining({
-                type: 'pi',
-                sessionId: 'sess-g',
-                cwd: matchingCwd,
-                firstUserMessage: 'first matching message',
-                sessionFilePath: matchingSession,
-            }),
-        ]);
-    });
-
-    function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
-        return {
-            pid: 1,
-            command: 'pi',
-            cwd: '/repo',
-            tty: 'ttys001',
-            startTime: new Date('2026-06-10T08:58:20.000Z'),
-            ...overrides,
-        };
-    }
-
-    function writePiSession(cwd: string, entries: Array<Record<string, unknown> | string>): string {
-        const projectDir = path.join(sessionsDir, encodeProjectDir(cwd));
-        fs.mkdirSync(projectDir, { recursive: true });
-        const sessionId = entries
-            .map((entry) => typeof entry === 'string' ? undefined : entry.sessionId)
-            .find((value): value is string => typeof value === 'string') ?? cryptoRandomSessionId();
-        const filePath = path.join(projectDir, `2026-06-10T08-58-20-754Z_${sessionId}.jsonl`);
-        fs.writeFileSync(
-            filePath,
-            entries.map((entry) => typeof entry === 'string' ? entry : JSON.stringify(entry)).join('\n'),
-        );
-        return filePath;
-    }
-
-    function writePiSessionWithFileName(cwd: string, fileName: string, entries: Array<Record<string, unknown> | string>): string {
-        const projectDir = path.join(sessionsDir, encodeProjectDir(cwd));
-        fs.mkdirSync(projectDir, { recursive: true });
-        const filePath = path.join(projectDir, fileName);
-        fs.writeFileSync(
-            filePath,
-            entries.map((entry) => typeof entry === 'string' ? entry : JSON.stringify(entry)).join('\n'),
-        );
-        return filePath;
-    }
-
-    function encodeProjectDir(cwd: string): string {
-        return cwd.replace(/\//g, '-').replace(/^-?/, '--') + '--';
-    }
-
-    function cryptoRandomSessionId(): string {
-        return `019eb0c1-06d2-71ed-90ee-${Math.random().toString(16).slice(2, 14).padEnd(12, '0')}`;
-    }
-});

package/src/__tests__/database/DurableAgentsDatabase.test.ts

@@ -1,102 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import Database from 'better-sqlite3';
-import { afterEach, describe, expect, it } from 'vitest';
-import { DatabaseConnection } from '../../database/connection.js';
-import { getSchemaVersion } from '../../database/schema.js';
-
-const roots: string[] = [];
-
-afterEach(() => {
-    for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-});
-
-function dbPath(): string {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'durable-agent-db-'));
-    roots.push(root);
-    return path.join(root, 'state', 'agents.db');
-}
-
-describe('durable agents schema', () => {
-    it('migrates to version 4 with durable constraints and indexes', () => {
-        const connection = new DatabaseConnection({ dbPath: dbPath() });
-        expect(getSchemaVersion(connection)).toBe(4);
-        const table = connection.queryOne<{ sql: string }>(
-            "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'durable_agents'",
-        );
-        expect(table?.sql).toContain("DEFAULT 'durable'");
-        expect(table?.sql).toContain("state IN ('ready','running','degraded')");
-        expect(connection.query<{ name: string }>(
-            "SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = 'durable_agents'",
-        ).map(({ name }) => name)).toEqual(expect.arrayContaining([
-            'idx_durable_agents_state', 'idx_durable_agents_list',
-        ]));
-        connection.close();
-    });
-
-    it('upgrades a version 3 database to nullable, unique provider sessions', () => {
-        const file = dbPath();
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        const raw = new Database(file);
-        raw.exec(`
-            CREATE TABLE durable_agents (
-                id TEXT PRIMARY KEY,
-                provider_session_id TEXT NOT NULL UNIQUE
-            );
-            INSERT INTO durable_agents (id, provider_session_id) VALUES ('existing', 'existing-session');
-            PRAGMA user_version = 3;
-        `);
-        raw.close();
-
-        const connection = new DatabaseConnection({ dbPath: file });
-        expect(getSchemaVersion(connection)).toBe(4);
-        expect(() => connection.execute(
-            'INSERT INTO durable_agents (id, provider_session_id) VALUES (?, NULL)', ['codex'],
-        )).not.toThrow();
-        expect(() => connection.execute(
-            'INSERT INTO durable_agents (id, provider_session_id) VALUES (?, ?)', ['duplicate', 'existing-session'],
-        )).toThrow(/UNIQUE/i);
-        connection.close();
-    });
-
-    it('enforces case-insensitive names and active-run consistency but permits new providers', () => {
-        const connection = new DatabaseConnection({ dbPath: dbPath() });
-        const insert = (name: string, provider: string, state = 'ready') => connection.execute(`
-            INSERT INTO durable_agents (
-                id, name, provider, mode, cwd, provider_session_id, state, session_health,
-                created_at, updated_at
-            ) VALUES (?, ?, ?, 'durable', '/tmp', ?, ?, 'uninitialized', ?, ?)
-        `, [crypto.randomUUID(), name, provider, crypto.randomUUID(), state, new Date().toISOString(), new Date().toISOString()]);
-        expect(() => insert('Alpha', 'future-provider')).not.toThrow();
-        expect(() => insert('alpha', 'claude')).toThrow(/UNIQUE/i);
-        expect(() => insert('Broken', 'claude', 'running')).toThrow(/CHECK/i);
-        connection.close();
-    });
-});
-
-describe('readonly DatabaseConnection', () => {
-    it('opens an already migrated database without changing it', () => {
-        const file = dbPath();
-        const writable = new DatabaseConnection({ dbPath: file });
-        writable.close();
-        const before = fs.statSync(file).mtimeMs;
-        const readonly = new DatabaseConnection({ dbPath: file, readonly: true });
-        expect(readonly.queryOne<{ user_version: number }>('PRAGMA user_version')?.user_version).toBe(4);
-        readonly.close();
-        expect(fs.statSync(file).mtimeMs).toBe(before);
-    });
-
-    it('does not create a missing database or migrate an old one', () => {
-        const missing = dbPath();
-        expect(() => new DatabaseConnection({ dbPath: missing, readonly: true })).toThrow(/readonly.*exist/i);
-        expect(fs.existsSync(missing)).toBe(false);
-
-        fs.mkdirSync(path.dirname(missing), { recursive: true });
-        const raw = new Database(missing);
-        raw.pragma('user_version = 2');
-        raw.close();
-        expect(() => new DatabaseConnection({ dbPath: missing, readonly: true })).toThrow(/schema version 3/i);
-        expect(new Database(missing, { readonly: true }).pragma('user_version', { simple: true })).toBe(2);
-    });
-});