opentasks 0.0.1 → 0.0.2

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

@@ -0,0 +1,669 @@
+/**
+ * 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