kenaz 0.0.0-stage → 0.3.2

package/core/.specialist/tools/lib/project-resolver.test.js

@@ -0,0 +1,241 @@
+// Unit tests for project-resolver.js
+// Tests AC1, AC3, AC4, AC5 (AC2 requires file integration)
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const assert = require('assert');
+
+const resolver = require('./project-resolver.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); console.log('  PASS:', name); passed++; }
+  catch (e) { console.error('  FAIL:', name, '--', e.message); failed++; }
+}
+
+// ---- Setup: temp fixture dirs ----
+const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), 'resolver-test-'));
+const projectA = path.join(tmpBase, 'projectA'); // simulates esp32
+const projectB = path.join(tmpBase, 'projectB'); // simulates deardearly
+const coreDir = path.join(tmpBase, 'core');
+
+for (const d of [projectA, projectB, coreDir]) {
+  fs.mkdirSync(path.join(d, '.kenaz', 'specialist'), { recursive: true });
+}
+fs.mkdirSync(path.join(coreDir, '.specialist'), { recursive: true });
+
+// Temp pin file to avoid touching real system
+const tmpPinFile = path.join(coreDir, '.kenaz', 'specialist', 'ansuz_project_pins.json');
+
+// Monkey-patch PIN_FILE reference - we override via the module's own writePin/readPins
+// by writing to the actual PIN_FILE. For tests, we'll work with a test-scoped pin path
+// by using a wrapper that sets up isolated state.
+
+function withIsolatedPins(fn) {
+  // Save original pin file location by using a temp copy
+  const origFile = resolver.PIN_FILE;
+  // We'll write a test pins file directly at the real PIN_FILE path,
+  // then restore after the test
+  const backup = fs.existsSync(origFile) ? fs.readFileSync(origFile, 'utf8') : null;
+  try {
+    // Clear pin file for isolation
+    const dir = path.dirname(origFile);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(origFile, '{}', 'utf8');
+    fn(origFile);
+  } finally {
+    if (backup !== null) fs.writeFileSync(origFile, backup, 'utf8');
+    else { try { fs.unlinkSync(origFile); } catch (_) {} }
+  }
+}
+
+// ---- AC5: Priority chain unit tests ----
+console.log('\n[AC5] Priority chain unit tests');
+
+test('extractCliFlag: --flag value form', function() {
+  const val = resolver.extractCliFlag(['--project-path', '/some/path'], 'project-path');
+  assert.strictEqual(val, '/some/path');
+});
+
+test('extractCliFlag: --flag=value form', function() {
+  const val = resolver.extractCliFlag(['--project-path=/some/path'], 'project-path');
+  assert.strictEqual(val, '/some/path');
+});
+
+test('extractCliFlag: not present returns null', function() {
+  const val = resolver.extractCliFlag(['--other-flag', 'val'], 'project-path');
+  assert.strictEqual(val, null);
+});
+
+test('extractCliProjectPath: resolves to absolute path', function() {
+  const val = resolver.extractCliProjectPath(['--project-path', tmpBase]);
+  assert.strictEqual(val, path.resolve(tmpBase));
+});
+
+test('resolveProjectPath: CLI --project-path wins (source=cli)', function() {
+  withIsolatedPins(function() {
+    // Even if there is a pin, CLI wins
+    resolver.writePin('session-X', projectB);
+    const result = resolver.resolveProjectPath({
+      cliProjectPath: projectA,
+      sessionId: 'session-X',
+      argv: []
+    });
+    assert.strictEqual(result.source, 'cli');
+    assert.strictEqual(result.projectPath, projectA);
+  });
+});
+
+test('resolveProjectPath: pin file wins when sessionId known (source=pin)', function() {
+  withIsolatedPins(function() {
+    resolver.writePin('session-pinned', projectA);
+    const result = resolver.resolveProjectPath({
+      cliProjectPath: null,
+      sessionId: 'session-pinned',
+      argv: []
+    });
+    assert.strictEqual(result.source, 'pin');
+    assert.strictEqual(result.projectPath, path.resolve(projectA));
+  });
+});
+
+test('resolveProjectPath: unknown sessionId falls to base (source=base)', function() {
+  withIsolatedPins(function() {
+    const result = resolver.resolveProjectPath({
+      cliProjectPath: null,
+      sessionId: 'nonexistent-session-id-12345',
+      argv: [],
+      useLatestPinFallback: false
+    });
+    // Should be base or cwd depending on cwd
+    assert.ok(result.source === 'base' || result.source === 'cwd', 'expected base or cwd, got: ' + result.source);
+  });
+});
+
+// ---- AC3: Two concurrent pins resolve independently ----
+console.log('\n[AC3] Two concurrent pins resolve independently');
+
+test('AC3: session-A -> projectA, session-B -> projectB, no clobbering', function() {
+  withIsolatedPins(function() {
+    resolver.writePin('session-A', projectA);
+    resolver.writePin('session-B', projectB);
+
+    const resultA = resolver.resolveProjectPath({ cliProjectPath: null, sessionId: 'session-A', argv: [] });
+    const resultB = resolver.resolveProjectPath({ cliProjectPath: null, sessionId: 'session-B', argv: [] });
+
+    assert.strictEqual(resultA.source, 'pin', 'session-A source should be pin');
+    assert.strictEqual(resultA.projectPath, path.resolve(projectA), 'session-A should resolve to projectA');
+    assert.strictEqual(resultB.source, 'pin', 'session-B source should be pin');
+    assert.strictEqual(resultB.projectPath, path.resolve(projectB), 'session-B should resolve to projectB');
+    assert.notStrictEqual(resultA.projectPath, resultB.projectPath, 'results must differ');
+  });
+});
+
+test('AC3: pin map has two independent entries after two writes', function() {
+  withIsolatedPins(function() {
+    resolver.writePin('session-A', projectA);
+    resolver.writePin('session-B', projectB);
+    const pins = resolver.readPins();
+    assert.ok('session-A' in pins, 'session-A entry exists');
+    assert.ok('session-B' in pins, 'session-B entry exists');
+    assert.strictEqual(pins['session-A'].project_path, path.resolve(projectA));
+    assert.strictEqual(pins['session-B'].project_path, path.resolve(projectB));
+  });
+});
+
+// ---- AC4: No pin + no flag = backward compat ----
+console.log('\n[AC4] No pin + no flag = backward compat');
+
+test('AC4: empty pin file + no argv + no sessionId -> base or cwd (not error)', function() {
+  withIsolatedPins(function() {
+    const result = resolver.resolveProjectPath({
+      cliProjectPath: null,
+      sessionId: null,
+      argv: [],
+      useLatestPinFallback: false
+    });
+    // Must return something valid (base or cwd)
+    assert.ok(result.projectPath, 'must return a path');
+    assert.ok(result.source === 'base' || result.source === 'cwd', 'source must be base or cwd, got: ' + result.source);
+  });
+});
+
+test('AC4: resolve() convenience function returns string (no crash)', function() {
+  withIsolatedPins(function() {
+    const p = resolver.resolve(null);
+    assert.strictEqual(typeof p, 'string', 'must return a string');
+    assert.ok(p.length > 0, 'must be non-empty');
+  });
+});
+
+// ---- AC1 simulation: pin for session-S -> projectA, handoff written to projectA ----
+console.log('\n[AC1] Pin routing simulation (fixture-based)');
+
+test('AC1: with pin session-S -> projectA, lookupPin returns projectA', function() {
+  withIsolatedPins(function() {
+    resolver.writePin('session-S', projectA);
+    const resolved = resolver.lookupPin('session-S');
+    assert.strictEqual(resolved, path.resolve(projectA));
+    // Confirm it is NOT the same as projectB (core leak simulation)
+    assert.notStrictEqual(resolved, path.resolve(projectB));
+  });
+});
+
+// ---- kenazPath helper ----
+console.log('\n[kenazPath] helper tests');
+
+test('kenazPath: builds correct nested path', function() {
+  const p = resolver.kenazPath('/some/project', 'specialist', 'ansuz_session.json');
+  assert.strictEqual(p, path.join('/some/project', '.kenaz', 'specialist', 'ansuz_session.json'));
+});
+
+test('kenazPath: no segments gives .kenaz root', function() {
+  const p = resolver.kenazPath('/some/project');
+  assert.strictEqual(p, path.join('/some/project', '.kenaz'));
+});
+
+// ---- TTL pruning ----
+console.log('\n[TTL] Stale entry pruning');
+
+test('TTL: stale entry is pruned on next write', function() {
+  withIsolatedPins(function() {
+    // Manually write a stale pin (8 days old)
+    const stalePins = {
+      'stale-session': {
+        project_path: projectA,
+        pinned_at: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000).toISOString()
+      }
+    };
+    fs.writeFileSync(resolver.PIN_FILE, JSON.stringify(stalePins), 'utf8');
+    // Write a new pin -- this triggers prune
+    resolver.writePin('fresh-session', projectB);
+    const pins = resolver.readPins();
+    assert.ok(!('stale-session' in pins), 'stale entry should be pruned');
+    assert.ok('fresh-session' in pins, 'fresh entry should remain');
+  });
+});
+
+test('TTL: lookupPin returns null for stale entry', function() {
+  withIsolatedPins(function() {
+    const stalePins = {
+      'stale-session': {
+        project_path: projectA,
+        pinned_at: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000).toISOString()
+      }
+    };
+    fs.writeFileSync(resolver.PIN_FILE, JSON.stringify(stalePins), 'utf8');
+    const result = resolver.lookupPin('stale-session');
+    assert.strictEqual(result, null, 'stale pin should return null');
+  });
+});
+
+// ---- Cleanup ----
+try { fs.rmSync(tmpBase, { recursive: true, force: true }); } catch (_) {}
+
+// Summary
+console.log('\n====');
+console.log('Passed:', passed, '/ Total:', passed + failed);
+if (failed > 0) { console.error('FAILED:', failed); process.exit(1); }
+else { console.log('ALL PASS'); }