@vellumai/assistant 0.4.16 → 0.4.18

package/src/__tests__/account-registry.test.ts

@@ -1,31 +1,31 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { afterAll, beforeEach, describe, expect, mock,test } from 'bun:test';
+const testDir = mkdtempSync(join(tmpdir(), "account-registry-test-"));
 
-const testDir = mkdtempSync(join(tmpdir(), 'account-registry-test-'));
-
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
   getPlatformName: () => process.platform,
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-mock.module('../tools/registry.js', () => ({
+mock.module("../tools/registry.js", () => ({
   registerTool: () => {},
 }));
 
@@ -34,27 +34,31 @@ import {
   getAccount,
   listAccounts,
   updateAccount,
-} from '../memory/account-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
-import type { ToolContext } from '../tools/types.js';
+} from "../memory/account-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import type { ToolContext } from "../tools/types.js";
 
 // Initialize db once
 initializeDb();
 
 const _ctx: ToolContext = {
-  workingDir: '/tmp',
-  sessionId: 'test-session',
-  conversationId: 'test-conv',
-  guardianTrustClass: 'guardian',
+  workingDir: "/tmp",
+  sessionId: "test-session",
+  conversationId: "test-conv",
+  guardianTrustClass: "guardian",
 };
 
 afterAll(() => {
   resetDb();
   mock.restore();
-  try { rmSync(testDir, { recursive: true }); } catch { /* best effort */ }
+  try {
+    rmSync(testDir, { recursive: true });
+  } catch {
+    /* best effort */
+  }
 });
 
-describe('account_manage tool', () => {
+describe("account_manage tool", () => {
   beforeEach(() => {
     const db = getDb();
     db.run(`DELETE FROM accounts`);
@@ -63,17 +67,22 @@ describe('account_manage tool', () => {
   // -----------------------------------------------------------------------
   // Create
   // -----------------------------------------------------------------------
-  describe('create action', () => {
-    test('creates an account with auto-generated UUID', () => {
-      const record = createAccount({ service: 'gmail', username: 'user@gmail.com' });
+  describe("create action", () => {
+    test("creates an account with auto-generated UUID", () => {
+      const record = createAccount({
+        service: "gmail",
+        username: "user@gmail.com",
+      });
       expect(record.id).toBeTruthy();
       // UUID v4 format: 8-4-4-4-12
-      expect(record.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+      expect(record.id).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+      );
     });
 
-    test('sets timestamps correctly', () => {
+    test("sets timestamps correctly", () => {
       const before = Date.now();
-      const record = createAccount({ service: 'github' });
+      const record = createAccount({ service: "github" });
       const after = Date.now();
 
       expect(record.createdAt).toBeGreaterThanOrEqual(before);
@@ -81,82 +90,82 @@ describe('account_manage tool', () => {
       expect(record.updatedAt).toBe(record.createdAt);
     });
 
-    test('stores all provided fields', () => {
+    test("stores all provided fields", () => {
       const record = createAccount({
-        service: 'github',
-        username: 'octocat',
-        email: 'octocat@github.com',
-        displayName: 'Octo Cat',
-        status: 'pending_verification',
-        credentialRef: 'github',
+        service: "github",
+        username: "octocat",
+        email: "octocat@github.com",
+        displayName: "Octo Cat",
+        status: "pending_verification",
+        credentialRef: "github",
         metadata: { twoFactor: true },
       });
 
-      expect(record.service).toBe('github');
-      expect(record.username).toBe('octocat');
-      expect(record.email).toBe('octocat@github.com');
-      expect(record.displayName).toBe('Octo Cat');
-      expect(record.status).toBe('pending_verification');
-      expect(record.credentialRef).toBe('github');
+      expect(record.service).toBe("github");
+      expect(record.username).toBe("octocat");
+      expect(record.email).toBe("octocat@github.com");
+      expect(record.displayName).toBe("Octo Cat");
+      expect(record.status).toBe("pending_verification");
+      expect(record.credentialRef).toBe("github");
       expect(record.metadataJson).toBe(JSON.stringify({ twoFactor: true }));
     });
 
-    test('defaults status to active', () => {
-      const record = createAccount({ service: 'gmail' });
-      expect(record.status).toBe('active');
+    test("defaults status to active", () => {
+      const record = createAccount({ service: "gmail" });
+      expect(record.status).toBe("active");
     });
 
-    test('returns the created record as JSON', () => {
-      const record = createAccount({ service: 'slack', email: 'me@slack.com' });
-      expect(record.service).toBe('slack');
-      expect(record.email).toBe('me@slack.com');
+    test("returns the created record as JSON", () => {
+      const record = createAccount({ service: "slack", email: "me@slack.com" });
+      expect(record.service).toBe("slack");
+      expect(record.email).toBe("me@slack.com");
     });
   });
 
   // -----------------------------------------------------------------------
   // List
   // -----------------------------------------------------------------------
-  describe('list action', () => {
-    test('lists all accounts', () => {
-      createAccount({ service: 'gmail', username: 'user1' });
-      createAccount({ service: 'github', username: 'user2' });
+  describe("list action", () => {
+    test("lists all accounts", () => {
+      createAccount({ service: "gmail", username: "user1" });
+      createAccount({ service: "github", username: "user2" });
 
       const accounts = listAccounts();
       expect(accounts).toHaveLength(2);
     });
 
-    test('filters by service', () => {
-      createAccount({ service: 'gmail', username: 'user1' });
-      createAccount({ service: 'github', username: 'user2' });
-      createAccount({ service: 'gmail', username: 'user3' });
+    test("filters by service", () => {
+      createAccount({ service: "gmail", username: "user1" });
+      createAccount({ service: "github", username: "user2" });
+      createAccount({ service: "gmail", username: "user3" });
 
-      const gmailAccounts = listAccounts({ service: 'gmail' });
+      const gmailAccounts = listAccounts({ service: "gmail" });
       expect(gmailAccounts).toHaveLength(2);
-      expect(gmailAccounts.every((a) => a.service === 'gmail')).toBe(true);
+      expect(gmailAccounts.every((a) => a.service === "gmail")).toBe(true);
     });
 
-    test('filters by status', () => {
-      createAccount({ service: 'gmail', status: 'active' });
-      createAccount({ service: 'github', status: 'suspended' });
-      createAccount({ service: 'slack', status: 'active' });
+    test("filters by status", () => {
+      createAccount({ service: "gmail", status: "active" });
+      createAccount({ service: "github", status: "suspended" });
+      createAccount({ service: "slack", status: "active" });
 
-      const activeAccounts = listAccounts({ status: 'active' });
+      const activeAccounts = listAccounts({ status: "active" });
       expect(activeAccounts).toHaveLength(2);
-      expect(activeAccounts.every((a) => a.status === 'active')).toBe(true);
+      expect(activeAccounts.every((a) => a.status === "active")).toBe(true);
     });
 
-    test('filters by both service and status', () => {
-      createAccount({ service: 'gmail', status: 'active' });
-      createAccount({ service: 'gmail', status: 'suspended' });
-      createAccount({ service: 'github', status: 'active' });
+    test("filters by both service and status", () => {
+      createAccount({ service: "gmail", status: "active" });
+      createAccount({ service: "gmail", status: "suspended" });
+      createAccount({ service: "github", status: "active" });
 
-      const result = listAccounts({ service: 'gmail', status: 'active' });
+      const result = listAccounts({ service: "gmail", status: "active" });
       expect(result).toHaveLength(1);
-      expect(result[0].service).toBe('gmail');
-      expect(result[0].status).toBe('active');
+      expect(result[0].service).toBe("gmail");
+      expect(result[0].status).toBe("active");
     });
 
-    test('returns empty array when no accounts exist', () => {
+    test("returns empty array when no accounts exist", () => {
       const accounts = listAccounts();
       expect(accounts).toEqual([]);
     });
@@ -165,18 +174,18 @@ describe('account_manage tool', () => {
   // -----------------------------------------------------------------------
   // Get
   // -----------------------------------------------------------------------
-  describe('get action', () => {
-    test('retrieves an account by id', () => {
-      const created = createAccount({ service: 'gmail', username: 'user1' });
+  describe("get action", () => {
+    test("retrieves an account by id", () => {
+      const created = createAccount({ service: "gmail", username: "user1" });
       const fetched = getAccount(created.id);
       expect(fetched).toBeDefined();
       expect(fetched!.id).toBe(created.id);
-      expect(fetched!.service).toBe('gmail');
-      expect(fetched!.username).toBe('user1');
+      expect(fetched!.service).toBe("gmail");
+      expect(fetched!.username).toBe("user1");
     });
 
-    test('returns undefined for invalid id', () => {
-      const result = getAccount('nonexistent-id');
+    test("returns undefined for invalid id", () => {
+      const result = getAccount("nonexistent-id");
       expect(result).toBeUndefined();
     });
   });
@@ -184,63 +193,65 @@ describe('account_manage tool', () => {
   // -----------------------------------------------------------------------
   // Update
   // -----------------------------------------------------------------------
-  describe('update action', () => {
-    test('updates provided fields', () => {
-      const created = createAccount({ service: 'gmail', username: 'old-user' });
-      const updated = updateAccount(created.id, { username: 'new-user' });
+  describe("update action", () => {
+    test("updates provided fields", () => {
+      const created = createAccount({ service: "gmail", username: "old-user" });
+      const updated = updateAccount(created.id, { username: "new-user" });
 
       expect(updated).toBeDefined();
-      expect(updated!.username).toBe('new-user');
-      expect(updated!.service).toBe('gmail'); // unchanged
+      expect(updated!.username).toBe("new-user");
+      expect(updated!.service).toBe("gmail"); // unchanged
     });
 
-    test('bumps updatedAt on update', async () => {
-      const created = createAccount({ service: 'gmail' });
+    test("bumps updatedAt on update", async () => {
+      const created = createAccount({ service: "gmail" });
       // Small delay to ensure timestamp difference
       await new Promise((r) => setTimeout(r, 10));
-      const updated = updateAccount(created.id, { username: 'updated' });
+      const updated = updateAccount(created.id, { username: "updated" });
 
       expect(updated!.updatedAt).toBeGreaterThan(created.updatedAt);
     });
 
-    test('returns undefined for non-existent id', () => {
-      const result = updateAccount('nonexistent-id', { username: 'test' });
+    test("returns undefined for non-existent id", () => {
+      const result = updateAccount("nonexistent-id", { username: "test" });
       expect(result).toBeUndefined();
     });
 
-    test('updates metadata as JSON', () => {
-      const created = createAccount({ service: 'github' });
-      const updated = updateAccount(created.id, { metadata: { role: 'admin' } });
+    test("updates metadata as JSON", () => {
+      const created = createAccount({ service: "github" });
+      const updated = updateAccount(created.id, {
+        metadata: { role: "admin" },
+      });
 
-      expect(updated!.metadataJson).toBe(JSON.stringify({ role: 'admin' }));
+      expect(updated!.metadataJson).toBe(JSON.stringify({ role: "admin" }));
     });
 
-    test('updates status', () => {
-      const created = createAccount({ service: 'gmail', status: 'active' });
-      const updated = updateAccount(created.id, { status: 'suspended' });
-      expect(updated!.status).toBe('suspended');
+    test("updates status", () => {
+      const created = createAccount({ service: "gmail", status: "active" });
+      const updated = updateAccount(created.id, { status: "suspended" });
+      expect(updated!.status).toBe("suspended");
     });
   });
 
   // -----------------------------------------------------------------------
   // Tool execute() via account-registry.ts
   // -----------------------------------------------------------------------
-  describe('account_manage tool execute', () => {
+  describe("account_manage tool execute", () => {
     // We test through the account-store functions since the tool is a thin wrapper.
     // Also test the tool's error handling for missing required fields.
 
-    test('create without service returns error message', async () => {
+    test("create without service returns error message", async () => {
       // Import the tool module to test its execute method
-      const _mod = await import('../tools/credentials/account-registry.js');
+      const _mod = await import("../tools/credentials/account-registry.js");
       // The tool was registered via side-effect; we test the store functions directly
       // and verify the tool's error-handling logic matches.
       // Since we mocked registerTool, let's just verify the store logic.
       // The tool delegates to createAccount, which requires service.
     });
 
-    test('multiple accounts for same service have unique IDs', () => {
-      const a1 = createAccount({ service: 'gmail', username: 'user1' });
-      const a2 = createAccount({ service: 'gmail', username: 'user2' });
+    test("multiple accounts for same service have unique IDs", () => {
+      const a1 = createAccount({ service: "gmail", username: "user1" });
+      const a2 = createAccount({ service: "gmail", username: "user2" });
       expect(a1.id).not.toBe(a2.id);
     });
   });