@liquidmetal-ai/precip 1.0.0

package/src/mounts/mount-manager.test.ts

@@ -0,0 +1,516 @@
+/**
+ * Simple unit test for MountManager.getMountsDescription()
+ * This isolates the mount description functionality from WASM dependencies
+ */
+
+import { describe, it, expect } from 'vitest';
+import { MountManager } from './mount-manager.js';
+
+// Shared mock factories — cast as `any` to satisfy interface types in tests
+const mockBucketResource = () =>
+  ({
+    get: () => Promise.resolve(null),
+    put: () => Promise.resolve(),
+    list: () => Promise.resolve({ objects: [], delimitedPrefixes: [], truncated: false }),
+    delete: () => Promise.resolve(),
+    head: () => Promise.resolve(null)
+  }) as any;
+
+const mockSmartBucketResource = () =>
+  ({
+    ...mockBucketResource(),
+    search: () =>
+      Promise.resolve({
+        results: [],
+        pagination: { total: 0, page: 1, pageSize: 10, totalPages: 0, hasMore: false }
+      }),
+    chunkSearch: () => Promise.resolve({ results: [] }),
+    documentChat: () => Promise.resolve({ answer: '' }),
+    getPaginatedResults: () =>
+      Promise.resolve({
+        results: [],
+        pagination: { total: 0, page: 1, pageSize: 10, totalPages: 0, hasMore: false }
+      })
+  }) as any;
+
+const mockSqlResource = () =>
+  ({
+    prepare: () => ({
+      all: () => Promise.resolve({ success: true, results: [], meta: {} }),
+      first: () => Promise.resolve(null),
+      run: () => Promise.resolve({ success: true, results: [], meta: {} })
+    }),
+    exec: () => Promise.resolve({ count: 0, duration: 0 }),
+    batch: () => Promise.resolve([])
+  }) as any;
+
+const mockKvResource = () =>
+  ({
+    get: () => Promise.resolve(null),
+    put: () => Promise.resolve(),
+    list: () => Promise.resolve({ keys: [], list_complete: true, cacheStatus: null }),
+    delete: () => Promise.resolve(),
+    getWithMetadata: () => Promise.resolve({ value: null, metadata: null, cacheStatus: null }),
+    clear: () => Promise.resolve({ deleted: 0, total: 0 })
+  }) as any;
+
+const mockActorNamespaceResource = () =>
+  ({
+    idFromName: (_name: string) => ({ toString: () => _name, equals: () => false, name: _name }),
+    get: () => ({})
+  }) as any;
+
+const mockActorStorageResource = () =>
+  ({
+    get: () => Promise.resolve(undefined),
+    put: () => Promise.resolve(),
+    delete: () => Promise.resolve(false),
+    deleteAll: () => Promise.resolve(),
+    list: () => Promise.resolve(new Map()),
+    getAlarm: () => Promise.resolve(null),
+    setAlarm: () => Promise.resolve(),
+    deleteAlarm: () => Promise.resolve()
+  }) as any;
+
+describe('MountManager - getMountsDescription', () => {
+  it('should generate empty description for no mounts', () => {
+    const manager = new MountManager({});
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toBe('');
+  });
+
+  it('should generate description for Buckets', () => {
+    const manager = new MountManager({
+      'user-data': {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('AVAILABLE STORAGE');
+    expect(desc).toContain('## File Storage');
+    expect(desc).toContain('/user-data/');
+  });
+
+  it('should generate description for SmartBuckets', () => {
+    const manager = new MountManager({
+      knowledge: {
+        type: 'smartbucket',
+        resource: mockSmartBucketResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('AVAILABLE STORAGE');
+    expect(desc).toContain('## File Storage');
+    expect(desc).toContain('/knowledge/');
+    expect(desc).toContain('[searchable]');
+  });
+
+  it('should generate description for SqlDatabase', () => {
+    const manager = new MountManager({
+      analytics: {
+        type: 'database',
+        resource: mockSqlResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('AVAILABLE STORAGE');
+    expect(desc).toContain('## Databases');
+    expect(desc).toContain('/analytics');
+    expect(desc).toContain('query()');
+  });
+
+  it('should generate description for KvCache', () => {
+    const manager = new MountManager({
+      cache: {
+        type: 'kv',
+        resource: mockKvResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('AVAILABLE STORAGE');
+    expect(desc).toContain('## Key-Value Cache');
+    expect(desc).toContain('/cache/<key>');
+  });
+
+  it('should generate description for mixed mount types including SmartBuckets', () => {
+    const manager = new MountManager({
+      files: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      },
+      knowledge: {
+        type: 'smartbucket',
+        resource: mockSmartBucketResource()
+      },
+      db: {
+        type: 'database',
+        resource: mockSqlResource()
+      },
+      kv: {
+        type: 'kv',
+        resource: mockKvResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## File Storage');
+    expect(desc).toContain('## Databases');
+    expect(desc).toContain('## Key-Value Cache');
+    expect(desc).toContain('/files/');
+    expect(desc).toContain('/knowledge/');
+    expect(desc).toContain('/db');
+    expect(desc).toContain('/kv/<key>');
+  });
+
+  it('should include correct mount references', () => {
+    const manager = new MountManager({
+      bucket1: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      },
+      db1: {
+        type: 'database',
+        resource: mockSqlResource()
+      },
+      kv1: {
+        type: 'kv',
+        resource: mockKvResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('/bucket1/');
+    expect(desc).toContain('/db1');
+    expect(desc).toContain('/kv1/<key>');
+  });
+
+  it('should detect SmartBucket type correctly', () => {
+    const manager = new MountManager({
+      smartbucket: {
+        type: 'smartbucket',
+        resource: mockSmartBucketResource()
+      }
+    });
+
+    const mount = manager.getMount('smartbucket');
+    expect(mount?.type).toBe('smartbucket');
+
+    const smartbucketMounts = manager.getMountsByType('smartbucket');
+    expect(smartbucketMounts.length).toBe(1);
+    expect(smartbucketMounts[0].name).toBe('smartbucket');
+  });
+
+  it('should format description with proper sections and spacing', () => {
+    const manager = new MountManager({
+      data: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toMatch(/AVAILABLE STORAGE:/);
+    expect(desc).toContain('/data/');
+  });
+
+  it('should mark SmartBuckets as searchable', () => {
+    const manager = new MountManager({
+      knowledge: {
+        type: 'smartbucket',
+        resource: mockSmartBucketResource()
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('[searchable]');
+    expect(desc).toContain('/knowledge/');
+  });
+});
+
+describe('MountManager - Mount Configs', () => {
+  it('should accept mount with explicit type', () => {
+    const manager = new MountManager({
+      data: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const mount = manager.getMount('data');
+    expect(mount?.type).toBe('bucket');
+    expect(mount?.name).toBe('data');
+    expect(mount?.description).toBeUndefined();
+  });
+
+  it('should accept mount with description and mode', () => {
+    const manager = new MountManager({
+      knowledge: {
+        type: 'bucket',
+        resource: mockBucketResource(),
+        description: 'Product documentation and API references',
+        mode: 'rw'
+      }
+    });
+
+    const mount = manager.getMount('knowledge');
+    expect(mount?.type).toBe('bucket');
+    expect(mount?.name).toBe('knowledge');
+    expect(mount?.description).toBe('Product documentation and API references');
+    expect(mount?.mode).toBe('rw');
+  });
+
+  it('should include description and mode in getMountsDescription output', () => {
+    const manager = new MountManager({
+      knowledge: {
+        type: 'bucket',
+        resource: mockBucketResource(),
+        description: 'Product documentation and API references',
+        mode: 'rw'
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+    expect(desc).toContain('Product documentation and API references');
+  });
+});
+
+describe('MountManager - Actor Mounts', () => {
+  it('should accept actor mount config', async () => {
+    const { z } = await import('zod');
+
+    const manager = new MountManager({
+      session: {
+        type: 'actor',
+        resource: mockActorNamespaceResource(),
+        description: 'Per-user session state',
+        methods: {
+          getState: {
+            description: 'Get current session state',
+            params: z.tuple([]),
+            returns: z.object({ loggedIn: z.boolean() })
+          }
+        }
+      }
+    });
+
+    const mount = manager.getMount('session');
+    expect(mount?.type).toBe('actor');
+    expect(mount?.name).toBe('session');
+    expect(mount?.description).toBe('Per-user session state');
+  });
+
+  it('should return actor mounts via getActorMounts', async () => {
+    const { z } = await import('zod');
+
+    const manager = new MountManager({
+      session: {
+        type: 'actor',
+        resource: mockActorNamespaceResource(),
+        description: 'Per-user session state',
+        methods: {
+          getState: {
+            description: 'Get current session state',
+            params: z.tuple([]),
+            returns: z.object({ loggedIn: z.boolean() })
+          }
+        }
+      },
+      data: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const actorMounts = manager.getActorMounts();
+    expect(actorMounts.size).toBe(1);
+    expect(actorMounts.has('session')).toBe(true);
+
+    const sessionMount = actorMounts.get('session');
+    expect(sessionMount?.methods).toBeDefined();
+    expect(sessionMount?.methods.getState).toBeDefined();
+  });
+
+  it('should generate actor documentation in getMountsDescription', async () => {
+    const { z } = await import('zod');
+
+    const manager = new MountManager({
+      session: {
+        type: 'actor',
+        resource: mockActorNamespaceResource(),
+        description: 'Per-user session state',
+        methods: {
+          getState: {
+            description: 'Get current session state',
+            params: z.tuple([]),
+            returns: z.object({ loggedIn: z.boolean() })
+          },
+          updatePrefs: {
+            description: 'Update user preferences',
+            params: z.tuple([z.object({ theme: z.enum(['light', 'dark']).optional() }).describe('prefs')]),
+            returns: z.object({ success: z.boolean() })
+          }
+        }
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## Actors');
+    expect(desc).toContain('### /session');
+    expect(desc).toContain('Per-user session state');
+    expect(desc).toContain('getState');
+    expect(desc).toContain('Get current session state');
+    expect(desc).toContain('updatePrefs');
+    expect(desc).toContain('Update user preferences');
+    expect(desc).toContain('actor("/session"');
+  });
+});
+
+describe('MountManager - Actor Storage Mounts', () => {
+  it('should accept actor-storage mount config', () => {
+    const manager = new MountManager({
+      state: {
+        type: 'actor-storage',
+        resource: mockActorStorageResource(),
+        description: 'Actor local state',
+        mode: 'rw'
+      }
+    });
+
+    const mount = manager.getMount('state');
+    expect(mount?.type).toBe('actor-storage');
+    expect(mount?.name).toBe('state');
+    expect(mount?.description).toBe('Actor local state');
+    expect(mount?.mode).toBe('rw');
+  });
+
+  it('should generate actor-storage description in getMountsDescription', () => {
+    const manager = new MountManager({
+      state: {
+        type: 'actor-storage',
+        resource: mockActorStorageResource(),
+        description: 'Session state',
+        mode: 'rw'
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## Actor State');
+    expect(desc).toContain('Strongly consistent');
+    expect(desc).toContain('/state/<key>');
+    expect(desc).toContain('Session state');
+    expect(desc).toContain('read-write');
+  });
+
+  it('should generate KV cache description with semantic information', () => {
+    const manager = new MountManager({
+      cache: {
+        type: 'kv',
+        resource: mockKvResource(),
+        description: 'Session cache',
+        mode: 'rw'
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## Key-Value Cache');
+    expect(desc).toContain('Ephemeral');
+    expect(desc).toContain('expiration');
+    expect(desc).toContain('/cache/<key>');
+  });
+
+  it('should generate file storage description with semantic information', () => {
+    const manager = new MountManager({
+      uploads: {
+        type: 'bucket',
+        resource: mockBucketResource(),
+        description: 'User files',
+        mode: 'rw'
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## File Storage');
+    expect(desc).toContain('Durable object storage');
+    expect(desc).toContain('contentType');
+    expect(desc).toContain('/uploads/');
+  });
+
+  it('should include actor-storage in mixed mount descriptions', () => {
+    const manager = new MountManager({
+      files: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      },
+      cache: {
+        type: 'kv',
+        resource: mockKvResource()
+      },
+      state: {
+        type: 'actor-storage',
+        resource: mockActorStorageResource(),
+        mode: 'rw'
+      }
+    });
+
+    const desc = manager.getMountsDescription();
+
+    expect(desc).toContain('## File Storage');
+    expect(desc).toContain('## Key-Value Cache');
+    expect(desc).toContain('## Actor State');
+    expect(desc).toContain('/files/');
+    expect(desc).toContain('/cache/<key>');
+    expect(desc).toContain('/state/<key>');
+  });
+});
+
+describe('MountManager - Path Parsing', () => {
+  it('should parse bucket path correctly', () => {
+    const manager = new MountManager({
+      data: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const parsed = manager.parsePath('/data/path/to/file.txt');
+    expect(parsed.mountName).toBe('data');
+    expect(parsed.path).toBe('path/to/file.txt');
+  });
+
+  it('should parse path without trailing path', () => {
+    const manager = new MountManager({
+      data: {
+        type: 'bucket',
+        resource: mockBucketResource()
+      }
+    });
+
+    const parsed = manager.parsePath('/data');
+    expect(parsed.mountName).toBe('data');
+    expect(parsed.path).toBe('');
+  });
+
+  it('should reject paths without leading slash', () => {
+    const manager = new MountManager({});
+
+    expect(() => manager.parsePath('data/file.txt')).toThrow('Paths must start with /');
+  });
+});