opentasks 0.0.4 → 0.0.6

package/dist/daemon/__tests__/multi-location.test.js

@@ -1,669 +0,0 @@
-/**
- * Tests for Multi-Location Daemon (Phase B)
- *
- * Tests the multi-location daemon mode where a single daemon
- * manages multiple worktree locations under one git repo.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { createDaemon, } from '../lifecycle.js';
-import { createIPCClient } from '../ipc.js';
-import { DaemonError } from '../types.js';
-import { createSingleLocationResolver, createMultiLocationResolver, } from '../location-state.js';
-// ============================================================================
-// Mock Helpers
-// ============================================================================
-function createMockStore() {
-    const nodes = new Map();
-    return {
-        initialize: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-        flush: vi.fn().mockResolvedValue(undefined),
-        createNode: vi.fn().mockImplementation(async (input) => {
-            const node = {
-                id: `i-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`,
-                uuid: '550e8400-e29b-41d4-a716-446655440000',
-                type: input.type || 'issue',
-                title: input.title,
-                status: input.status || 'open',
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-                ...input,
-            };
-            nodes.set(node.id, node);
-            return node;
-        }),
-        getNode: vi.fn().mockImplementation(async (id) => {
-            return nodes.get(id) ?? null;
-        }),
-        updateNode: vi.fn().mockImplementation(async (id, updates) => {
-            const node = nodes.get(id);
-            if (!node)
-                throw new Error(`Node not found: ${id}`);
-            const updated = { ...node, ...updates, updated_at: new Date().toISOString() };
-            nodes.set(id, updated);
-            return updated;
-        }),
-        deleteNode: vi.fn().mockResolvedValue(undefined),
-        restoreNode: vi.fn(),
-        createEdge: vi.fn().mockImplementation(async (input) => {
-            const edge = {
-                id: `x-${Date.now().toString(36)}`,
-                uuid: '550e8400-e29b-41d4-a716-446655440001',
-                from_id: input.from_id,
-                to_id: input.to_id,
-                type: input.type || 'blocks',
-                created_at: new Date().toISOString(),
-            };
-            return edge;
-        }),
-        getEdge: vi.fn().mockResolvedValue(null),
-        deleteEdge: vi.fn().mockResolvedValue(undefined),
-        addTags: vi.fn(),
-        removeTags: vi.fn(),
-        setTags: vi.fn(),
-        query: {
-            nodes: vi.fn().mockResolvedValue([]),
-            edges: vi.fn().mockResolvedValue([]),
-            edgesFrom: vi.fn().mockResolvedValue([]),
-            edgesTo: vi.fn().mockResolvedValue([]),
-            edgesFor: vi.fn().mockResolvedValue([]),
-            blockers: vi.fn().mockResolvedValue([]),
-            blocking: vi.fn().mockResolvedValue([]),
-            isBlocking: vi.fn().mockResolvedValue(false),
-            implementers: vi.fn().mockResolvedValue([]),
-            specs: vi.fn().mockResolvedValue([]),
-            children: vi.fn().mockResolvedValue([]),
-            parent: vi.fn().mockResolvedValue(null),
-            ancestors: vi.fn().mockResolvedValue([]),
-            descendants: vi.fn().mockResolvedValue([]),
-            ready: vi.fn().mockResolvedValue([]),
-            feedback: vi.fn().mockResolvedValue([]),
-            unresolvedFeedback: vi.fn().mockResolvedValue([]),
-        },
-        transaction: vi.fn(),
-    };
-}
-function createMockFlushManager() {
-    return {
-        markDirty: vi.fn(),
-        schedule: vi.fn(),
-        flush: vi.fn().mockResolvedValue(undefined),
-        pause: vi.fn(),
-        resume: vi.fn(),
-        finalFlush: vi.fn().mockResolvedValue(undefined),
-        hasPendingChanges: vi.fn().mockReturnValue(false),
-        getDirtyNodes: vi.fn().mockReturnValue([]),
-        paused: false,
-    };
-}
-function createMockWatcher() {
-    return {
-        start: vi.fn().mockResolvedValue(undefined),
-        stop: vi.fn().mockResolvedValue(undefined),
-        pause: vi.fn(),
-        resume: vi.fn(),
-        onchange: vi.fn(),
-        paused: false,
-    };
-}
-function createMockLocationState(hash, opentasksPath, primary = false) {
-    return {
-        hash,
-        opentasksPath,
-        store: createMockStore(),
-        flushManager: createMockFlushManager(),
-        watcher: createMockWatcher(),
-        primary,
-        healthy: true,
-    };
-}
-// ============================================================================
-// LocationResolver Unit Tests
-// ============================================================================
-describe('LocationResolver', () => {
-    describe('createSingleLocationResolver', () => {
-        it('should resolve any hash to the single state', () => {
-            const state = createMockLocationState('abc12345', '/tmp/.opentasks', true);
-            const resolver = createSingleLocationResolver(state);
-            expect(resolver.resolve()).toBe(state);
-            expect(resolver.resolve('abc12345')).toBe(state);
-            expect(resolver.resolve('anything')).toBe(state);
-        });
-        it('should return state as default', () => {
-            const state = createMockLocationState('abc12345', '/tmp/.opentasks', true);
-            const resolver = createSingleLocationResolver(state);
-            expect(resolver.getDefault()).toBe(state);
-        });
-        it('should list single location', () => {
-            const state = createMockLocationState('abc12345', '/tmp/.opentasks', true);
-            const resolver = createSingleLocationResolver(state);
-            const list = resolver.list();
-            expect(list).toHaveLength(1);
-            expect(list[0].hash).toBe('abc12345');
-            expect(list[0].primary).toBe(true);
-            expect(list[0].healthy).toBe(true);
-        });
-        it('should reject add in single-location mode', () => {
-            const state = createMockLocationState('abc12345', '/tmp/.opentasks', true);
-            const resolver = createSingleLocationResolver(state);
-            const newState = createMockLocationState('def67890', '/tmp2/.opentasks');
-            expect(() => resolver.add(newState)).toThrow('Cannot add locations');
-        });
-        it('should reject remove in single-location mode', async () => {
-            const state = createMockLocationState('abc12345', '/tmp/.opentasks', true);
-            const resolver = createSingleLocationResolver(state);
-            await expect(resolver.remove('abc12345')).rejects.toThrow('Cannot remove locations');
-        });
-    });
-    describe('createMultiLocationResolver', () => {
-        it('should resolve primary hash as default', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            const state = createMockLocationState('primary1', '/repo/.opentasks', true);
-            resolver.add(state);
-            expect(resolver.resolve()).toBe(state);
-            expect(resolver.getDefault()).toBe(state);
-        });
-        it('should resolve specific location by hash', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            const state1 = createMockLocationState('primary1', '/repo/.opentasks', true);
-            const state2 = createMockLocationState('worktree', '/wt/.opentasks');
-            resolver.add(state1);
-            resolver.add(state2);
-            expect(resolver.resolve('primary1')).toBe(state1);
-            expect(resolver.resolve('worktree')).toBe(state2);
-        });
-        it('should throw LOCATION_NOT_FOUND for unknown hash', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            const state = createMockLocationState('primary1', '/repo/.opentasks', true);
-            resolver.add(state);
-            expect(() => resolver.resolve('unknown')).toThrow(DaemonError);
-            expect(() => resolver.resolve('unknown')).toThrow('Location not found');
-        });
-        it('should list all locations', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            resolver.add(createMockLocationState('primary1', '/repo/.opentasks', true));
-            resolver.add(createMockLocationState('wt1', '/wt1/.opentasks'));
-            resolver.add(createMockLocationState('wt2', '/wt2/.opentasks'));
-            const list = resolver.list();
-            expect(list).toHaveLength(3);
-            expect(list.map(l => l.hash).sort()).toEqual(['primary1', 'wt1', 'wt2']);
-        });
-        it('should check has()', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            resolver.add(createMockLocationState('primary1', '/repo/.opentasks', true));
-            expect(resolver.has('primary1')).toBe(true);
-            expect(resolver.has('unknown')).toBe(false);
-        });
-        it('should add and remove locations', async () => {
-            const resolver = createMultiLocationResolver('primary1');
-            resolver.add(createMockLocationState('primary1', '/repo/.opentasks', true));
-            const wt = createMockLocationState('wt1', '/wt1/.opentasks');
-            resolver.add(wt);
-            expect(resolver.list()).toHaveLength(2);
-            await resolver.remove('wt1');
-            expect(resolver.list()).toHaveLength(1);
-            expect(resolver.has('wt1')).toBe(false);
-        });
-        it('should call teardown on remove', async () => {
-            const resolver = createMultiLocationResolver('primary1');
-            const wt = createMockLocationState('wt1', '/wt1/.opentasks');
-            resolver.add(wt);
-            await resolver.remove('wt1');
-            // Watcher stop should have been called
-            expect(wt.watcher.stop).toHaveBeenCalled();
-            // Final flush should have been called
-            expect(wt.flushManager.finalFlush).toHaveBeenCalled();
-            // Store close should have been called
-            expect(wt.store.close).toHaveBeenCalled();
-        });
-        it('should fallback to first location if primary not found', () => {
-            const resolver = createMultiLocationResolver('missing');
-            const state = createMockLocationState('fallback', '/fb/.opentasks');
-            resolver.add(state);
-            expect(resolver.getDefault()).toBe(state);
-        });
-        it('should throw when no locations available', () => {
-            const resolver = createMultiLocationResolver('primary1');
-            expect(() => resolver.resolve()).toThrow('No locations available');
-        });
-        it('should be idempotent on remove of non-existent hash', async () => {
-            const resolver = createMultiLocationResolver('primary1');
-            // Should not throw
-            await resolver.remove('nonexistent');
-        });
-    });
-});
-// ============================================================================
-// Multi-Location Daemon Integration Tests
-// ============================================================================
-describe('Multi-Location Daemon', () => {
-    let tempDir;
-    let gitCommonDir;
-    let primaryPath;
-    let worktreePath;
-    let registryPath;
-    let daemon;
-    let client;
-    /**
-     * Setup a simulated git repo structure with multiple worktree locations.
-     */
-    async function setupGitRepoStructure() {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'opentasks-multi-loc-'));
-        // Simulated repo structure:
-        // tempDir/repo/.git/         ← gitCommonDir
-        // tempDir/repo/.git/opentasks/worktrees.json
-        // tempDir/repo/.opentasks/   ← primary location
-        // tempDir/worktree1/.opentasks/  ← secondary location
-        gitCommonDir = path.join(tempDir, 'repo', '.git');
-        primaryPath = path.join(tempDir, 'repo', '.opentasks');
-        worktreePath = path.join(tempDir, 'worktree1', '.opentasks');
-        registryPath = path.join(tempDir, 'registry', 'registry.json');
-        // Create directories
-        await fs.mkdir(gitCommonDir, { recursive: true });
-        await fs.mkdir(path.join(gitCommonDir, 'opentasks'), { recursive: true });
-        await fs.mkdir(primaryPath, { recursive: true });
-        await fs.mkdir(worktreePath, { recursive: true });
-        // Create empty graph.jsonl files
-        await fs.writeFile(path.join(primaryPath, 'graph.jsonl'), '', 'utf-8');
-        await fs.writeFile(path.join(worktreePath, 'graph.jsonl'), '', 'utf-8');
-        // Create worktree registry
-        const worktreeRegistry = {
-            worktrees: [
-                {
-                    path: path.join(tempDir, 'repo'),
-                    opentasksPath: primaryPath,
-                    hash: 'pr1m4ry1',
-                    role: 'manager',
-                },
-                {
-                    path: path.join(tempDir, 'worktree1'),
-                    opentasksPath: worktreePath,
-                    hash: 'w0rktrs1',
-                    role: 'worker',
-                    redirectTarget: 'pr1m4ry1',
-                },
-            ],
-        };
-        await fs.writeFile(path.join(gitCommonDir, 'opentasks', 'worktrees.json'), JSON.stringify(worktreeRegistry, null, 2), 'utf-8');
-    }
-    function createMultiConfig(overrides = {}) {
-        return {
-            gitCommonDir,
-            version: '1.0.0-test',
-            registryPath,
-            shutdownTimeoutMs: 3000,
-            primaryLocationPath: primaryPath,
-            ...overrides,
-        };
-    }
-    beforeEach(async () => {
-        await setupGitRepoStructure();
-        daemon = null;
-        client = null;
-    });
-    afterEach(async () => {
-        if (client?.connected) {
-            client.disconnect();
-            client = null;
-        }
-        if (daemon) {
-            try {
-                await daemon.stop();
-            }
-            catch { /* ignore */ }
-            daemon = null;
-        }
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-    });
-    describe('creation', () => {
-        it('should create multi-location daemon with correct paths', () => {
-            daemon = createDaemon(createMultiConfig());
-            const expectedSocketPath = path.join(gitCommonDir, 'opentasks', 'daemon.sock');
-            expect(daemon.socketPath).toBe(expectedSocketPath);
-            expect(daemon.locationPath).toBe(path.join(gitCommonDir, 'opentasks'));
-        });
-        it('should start in stopped state', () => {
-            daemon = createDaemon(createMultiConfig());
-            const status = daemon.getStatus();
-            expect(status.state).toBe('stopped');
-        });
-    });
-    describe('start and stop', () => {
-        it('should start and initialize locations', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            const status = daemon.getStatus();
-            expect(status.state).toBe('running');
-            expect(status.locationCount).toBeGreaterThanOrEqual(1);
-        });
-        it('should stop cleanly', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            await daemon.stop();
-            const status = daemon.getStatus();
-            expect(status.state).toBe('stopped');
-        });
-        it('should reject double start', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            await expect(daemon.start()).rejects.toThrow(DaemonError);
-        });
-        it('should be idempotent on stop', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            await daemon.stop();
-            await daemon.stop();
-            await daemon.stop();
-            expect(daemon.getStatus().state).toBe('stopped');
-        });
-    });
-    describe('IPC operations', () => {
-        it('should accept IPC connections', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const result = await client.request('ping');
-            expect(result.pong).toBe(true);
-        });
-        it('should report location count in status', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const status = await client.request('status');
-            expect(status.state).toBe('running');
-            expect(status.locationCount).toBeGreaterThanOrEqual(1);
-        });
-        it('should report healthy status when all locations are up', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const health = await client.request('health');
-            expect(health.status).toBe('healthy');
-        });
-        it('should handle graph.create on default location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const node = await client.request('graph.create', {
-                type: 'issue',
-                title: 'Test Issue',
-                status: 'open',
-            });
-            expect(node.title).toBe('Test Issue');
-            expect(node.id).toBeTruthy();
-        });
-        it('should handle graph.create with explicit location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Create on primary location explicitly
-            const node = await client.request('graph.create', {
-                type: 'issue',
-                title: 'Primary Issue',
-                status: 'open',
-                location: 'pr1m4ry1',
-            });
-            expect(node.title).toBe('Primary Issue');
-        });
-        it('should route graph operations to specific worktree', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Create on worktree location
-            const node = await client.request('graph.create', {
-                type: 'issue',
-                title: 'Worktree Issue',
-                status: 'open',
-                location: 'w0rktrs1',
-            });
-            expect(node.title).toBe('Worktree Issue');
-        });
-        it('should return error for unknown location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // The IPC server wraps DaemonError as JSON-RPC Internal error
-            await expect(client.request('graph.create', {
-                type: 'issue',
-                title: 'Bad Location',
-                status: 'open',
-                location: 'unknown1',
-            })).rejects.toThrow('Internal error');
-        });
-    });
-    describe('location IPC methods', () => {
-        it('should list locations', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const locations = await client.request('location.list');
-            expect(locations.length).toBeGreaterThanOrEqual(1);
-            // Primary should be in the list
-            const primary = locations.find(l => l.primary);
-            expect(primary).toBeTruthy();
-        });
-        it('should list all registered worktrees', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const locations = await client.request('location.list');
-            const hashes = locations.map(l => l.hash);
-            // Should have both primary and worktree
-            expect(hashes).toContain('pr1m4ry1');
-            expect(hashes).toContain('w0rktrs1');
-        });
-        it('should unregister a location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Unregister worktree
-            const result = await client.request('location.unregister', {
-                hash: 'w0rktrs1',
-            });
-            expect(result.success).toBe(true);
-            // Verify it's gone
-            const locations = await client.request('location.list');
-            const hashes = locations.map(l => l.hash);
-            expect(hashes).not.toContain('w0rktrs1');
-        });
-        it('should dynamically register a new location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Create a new worktree location
-            const newWorktrePath = path.join(tempDir, 'worktree2', '.opentasks');
-            await fs.mkdir(newWorktrePath, { recursive: true });
-            await fs.writeFile(path.join(newWorktrePath, 'graph.jsonl'), '', 'utf-8');
-            // Register it
-            const result = await client.request('location.register', {
-                hash: 'n3wloc01',
-                opentasksPath: newWorktrePath,
-            });
-            expect(result.success).toBe(true);
-            // Verify it's in the list
-            const locations = await client.request('location.list');
-            const hashes = locations.map(l => l.hash);
-            expect(hashes).toContain('n3wloc01');
-        });
-        it('should fail to register invalid location path', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Try to register a path that doesn't exist
-            await expect(client.request('location.register', {
-                hash: 'bad1loc1',
-                opentasksPath: '/nonexistent/path/.opentasks',
-            })).rejects.toThrow();
-        });
-        it('should be idempotent for already-registered location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            // Re-register an existing location
-            const result = await client.request('location.register', {
-                hash: 'pr1m4ry1',
-                opentasksPath: primaryPath,
-            });
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('graceful degradation', () => {
-        it('should start even if secondary location is unreachable', async () => {
-            // Remove the worktree .opentasks dir to make it fail
-            await fs.rm(worktreePath, { recursive: true, force: true });
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            const status = daemon.getStatus();
-            expect(status.state).toBe('running');
-            // At least primary should be initialized
-            expect(status.locationCount).toBeGreaterThanOrEqual(1);
-        });
-        it('should fail if no locations can be initialized', async () => {
-            // Remove both locations
-            await fs.rm(primaryPath, { recursive: true, force: true });
-            await fs.rm(worktreePath, { recursive: true, force: true });
-            daemon = createDaemon(createMultiConfig());
-            await expect(daemon.start()).rejects.toThrow('No locations could be initialized');
-            expect(daemon.getStatus().state).toBe('stopped');
-        });
-    });
-    describe('flush operations', () => {
-        it('should flush specific location', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const result = await client.request('flush', {
-                location: 'pr1m4ry1',
-            });
-            expect(result.success).toBe(true);
-        });
-        it('should flush default location when no location specified', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const result = await client.request('flush');
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('shutdown via IPC', () => {
-        it('should shutdown multi-location daemon via IPC', async () => {
-            daemon = createDaemon(createMultiConfig());
-            await daemon.start();
-            client = createIPCClient(daemon.socketPath);
-            await client.connect();
-            const result = await client.request('shutdown');
-            expect(result.success).toBe(true);
-            client.disconnect();
-            client = null;
-            // Wait for shutdown
-            await new Promise((r) => setTimeout(r, 300));
-            expect(daemon.getStatus().state).toBe('stopped');
-        });
-    });
-});
-// ============================================================================
-// Backward Compatibility Tests
-// ============================================================================
-describe('Backward Compatibility', () => {
-    let tempDir;
-    let locationPath;
-    let registryPath;
-    let daemon;
-    let client;
-    beforeEach(async () => {
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'opentasks-compat-'));
-        locationPath = path.join(tempDir, '.opentasks');
-        registryPath = path.join(tempDir, 'registry', 'registry.json');
-        await fs.mkdir(locationPath, { recursive: true });
-        daemon = null;
-        client = null;
-    });
-    afterEach(async () => {
-        if (client?.connected) {
-            client.disconnect();
-            client = null;
-        }
-        if (daemon) {
-            try {
-                await daemon.stop();
-            }
-            catch { /* ignore */ }
-            daemon = null;
-        }
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-    });
-    it('should still work with single-location config (no gitCommonDir)', async () => {
-        const store = createMockStore();
-        daemon = createDaemon({
-            locationPath,
-            version: '1.0.0-test',
-            store,
-            registryPath,
-            shutdownTimeoutMs: 2000,
-        });
-        await daemon.start();
-        client = createIPCClient(daemon.socketPath);
-        await client.connect();
-        const result = await client.request('ping');
-        expect(result.pong).toBe(true);
-        const node = await client.request('graph.create', {
-            type: 'issue',
-            title: 'Compat Test',
-            status: 'open',
-        });
-        expect(node.title).toBe('Compat Test');
-        expect(store.createNode).toHaveBeenCalledOnce();
-        client.disconnect();
-        client = null;
-        await daemon.stop();
-        expect(daemon.getStatus().state).toBe('stopped');
-        expect(store.close).toHaveBeenCalledOnce();
-    });
-    it('single-location config should ignore location param', async () => {
-        const store = createMockStore();
-        daemon = createDaemon({
-            locationPath,
-            version: '1.0.0-test',
-            store,
-            registryPath,
-            shutdownTimeoutMs: 2000,
-        });
-        await daemon.start();
-        client = createIPCClient(daemon.socketPath);
-        await client.connect();
-        // Even with a location param, single-location resolves to the only store
-        const node = await client.request('graph.create', {
-            type: 'issue',
-            title: 'With Location',
-            status: 'open',
-            location: 'anyhash1',
-        });
-        expect(node.title).toBe('With Location');
-        expect(store.createNode).toHaveBeenCalledOnce();
-    });
-});
-//# sourceMappingURL=multi-location.test.js.map