gsd-pi 2.76.0 → 2.77.0-dev.1d17f366c

package/src/resources/extensions/gsd/tests/freeform-decisions.test.ts

@@ -6,6 +6,7 @@ import * as fs from 'node:fs';
 import {
   openDatabase,
   closeDatabase,
+  _getAdapter,
 } from '../gsd-db.ts';
 import {
   parseDecisionsTable,
@@ -30,6 +31,13 @@ function cleanupDir(dir: string): void {
   } catch { /* swallow */ }
 }
 
+/** Query all decisions from the DB ordered by seq. */
+function queryAllDecisions(): Array<Record<string, unknown>> {
+  const adapter = _getAdapter();
+  if (!adapter) return [];
+  return adapter.prepare('SELECT * FROM decisions ORDER BY seq').all();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Bug reproduction: freeform DECISIONS.md content destroyed (#2301)
 // ═══════════════════════════════════════════════════════════════════════════
@@ -87,6 +95,13 @@ describe('freeform-decisions', () => {
 
       assert.deepStrictEqual(result.id, 'D001', 'decision ID assigned correctly');
 
+      // ── Assert DB state ──
+      const dbRows = queryAllDecisions();
+      assert.equal(dbRows.length, 1, 'DB has exactly 1 decision after first save');
+      assert.equal(dbRows[0]['id'], 'D001', 'DB row has correct ID');
+      assert.equal(dbRows[0]['scope'], 'testing', 'DB row has correct scope');
+      assert.equal(dbRows[0]['decision'], 'Use Jest for unit tests', 'DB row has correct decision text');
+
       // Read back the file
       const afterContent = fs.readFileSync(mdPath, 'utf-8');
 
@@ -125,6 +140,13 @@ describe('freeform-decisions', () => {
 
       assert.deepStrictEqual(result2.id, 'D002', 'second decision ID assigned correctly');
 
+      // ── Assert DB state after second save ──
+      const dbRows2 = queryAllDecisions();
+      assert.equal(dbRows2.length, 2, 'DB has exactly 2 decisions after second save');
+      assert.equal(dbRows2[0]['id'], 'D001', 'first DB row still D001');
+      assert.equal(dbRows2[1]['id'], 'D002', 'second DB row is D002');
+      assert.equal(dbRows2[1]['scope'], 'ci', 'second DB row has correct scope');
+
       const afterContent2 = fs.readFileSync(mdPath, 'utf-8');
 
       assert.ok(
@@ -182,6 +204,12 @@ describe('freeform-decisions', () => {
       // But the new decision should be there.
       assert.deepStrictEqual(result.id, 'D001', 'gets D001 since DB was empty');
 
+      // ── Assert DB state ──
+      const dbRows = queryAllDecisions();
+      assert.equal(dbRows.length, 1, 'DB has exactly 1 decision');
+      assert.equal(dbRows[0]['id'], 'D001', 'DB row has correct ID');
+      assert.equal(dbRows[0]['decision'], 'Use Vitest', 'DB row has correct decision text');
+
       const afterContent = fs.readFileSync(mdPath, 'utf-8');
       // Table-format file gets fully regenerated — this is the normal path
       assert.ok(
@@ -218,6 +246,13 @@ describe('freeform-decisions', () => {
       assert.deepStrictEqual(result.id, 'D001', 'first decision gets D001');
       assert.ok(fs.existsSync(mdPath), 'DECISIONS.md created');
 
+      // ── Assert DB state ──
+      const dbRows = queryAllDecisions();
+      assert.equal(dbRows.length, 1, 'DB has exactly 1 decision');
+      assert.equal(dbRows[0]['id'], 'D001', 'DB row ID is D001');
+      assert.equal(dbRows[0]['scope'], 'arch', 'DB row scope is arch');
+      assert.equal(dbRows[0]['decision'], 'Brand new decision', 'DB row decision text matches');
+
       const content = fs.readFileSync(mdPath, 'utf-8');
       assert.ok(content.includes('# Decisions Register'), 'new file has header');
       assert.ok(content.includes('Brand new decision'), 'new file has decision');
@@ -227,6 +262,33 @@ describe('freeform-decisions', () => {
     }
   });
 
+  test('parallel saveDecisionToDb calls assign unique IDs', async () => {
+    const tmpDir = makeTmpDir();
+    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+    openDatabase(dbPath);
+
+    try {
+      const [r1, r2, r3] = await Promise.all([
+        saveDecisionToDb({ scope: 'a', decision: 'Decision A', choice: 'A', rationale: 'A' }, tmpDir),
+        saveDecisionToDb({ scope: 'b', decision: 'Decision B', choice: 'B', rationale: 'B' }, tmpDir),
+        saveDecisionToDb({ scope: 'c', decision: 'Decision C', choice: 'C', rationale: 'C' }, tmpDir),
+      ]);
+
+      const ids = new Set([r1.id, r2.id, r3.id]);
+      assert.strictEqual(ids.size, 3, `expected 3 unique IDs but got: ${[r1.id, r2.id, r3.id]}`);
+
+      // Verify all 3 decisions exist in the markdown file
+      const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+      const content = fs.readFileSync(mdPath, 'utf-8');
+      assert.ok(content.includes('Decision A'), 'Decision A in file');
+      assert.ok(content.includes('Decision B'), 'Decision B in file');
+      assert.ok(content.includes('Decision C'), 'Decision C in file');
+    } finally {
+      closeDatabase();
+      cleanupDir(tmpDir);
+    }
+  });
+
   // ═══════════════════════════════════════════════════════════════════════════
 
 });

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -0,0 +1,131 @@
+// GSD-2 — Tests for google-search deprecation stub (STUB-01, STUB-02)
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("google-search stub: default export is a function", async (_t) => {
+  // STUB-01: stub has a default export function accepting ExtensionAPI
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+  assert.equal(typeof stubFn, "function");
+});
+
+test("google-search stub: registers session_start handler", async (_t) => {
+  // STUB-01: stub calls pi.on("session_start", ...)
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedEvent: string | undefined;
+  let capturedHandler: unknown;
+
+  const mockPi = {
+    on(event: string, handler: unknown) {
+      capturedEvent = event;
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(capturedEvent, "session_start");
+  assert.equal(typeof capturedHandler, "function");
+});
+
+test("google-search stub: does NOT call registerTool", async (_t) => {
+  // STUB-02: stub is a no-op for tools
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let registerToolCalled = false;
+
+  const mockPi = {
+    on: (_event: string, _handler: unknown) => {},
+    registerTool: () => { registerToolCalled = true; },
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(registerToolCalled, false);
+});
+
+test("google-search stub: session_start warning contains package name", async (_t) => {
+  // STUB-01: warning includes @gsd-extensions/google-search
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    capturedMessage?.includes("@gsd-extensions/google-search"),
+    `Expected message to include "@gsd-extensions/google-search", got: "${capturedMessage}"`,
+  );
+});
+
+test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
+  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
+  // package is not yet on npm, so that command would 404. The message must
+  // explain the extraction is in progress and no user action is required.
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    !capturedMessage?.includes("gsd extensions install"),
+    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("not yet published"),
+    `Expected message to include "not yet published", got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("No action needed"),
+    `Expected message to include "No action needed", got: "${capturedMessage}"`,
+  );
+});