@liquidmetal-ai/precip 1.0.0

package/src/sandbox/bridges/search.test.ts

@@ -0,0 +1,475 @@
+import { describe, it, expect, vi } from 'vitest';
+import { executeWithAsyncHost } from '../test-helper.js';
+import { installSearch } from './search.js';
+import type { SearchMountInfo } from './search.js';
+
+function createMockSmartBucket() {
+  const searches = new Map<string, any>();
+
+  const mockSmartBucket: any = {
+    search: vi.fn(async ({ input, requestId }: { input: string; requestId: string }) => {
+      // Store the search with requestId for pagination
+      const page = 1;
+      const pageSize = 5;
+
+      // Simulate 12 results total (3 pages of 5)
+      const allResults = Array.from({ length: 12 }, (_, i) => ({
+        text: `Result ${i + 1} for ${input}`,
+        source: `source-${i + 1}.txt`,
+        score: 0.9 - (i * 0.05),
+        chunkSignature: `chunk-${i + 1}`
+      }));
+
+      const results = allResults.slice(0, pageSize);
+      searches.set(requestId, allResults);
+
+      return {
+        results,
+        pagination: {
+          total: allResults.length,
+          page,
+          pageSize,
+          hasMore: true
+        }
+      };
+    }),
+
+    chunkSearch: vi.fn(async ({ input, requestId: _requestId }: { input: string; requestId: string }) => {
+      // RAG-style search returns all results at once
+      return {
+        results: [
+          {
+            text: `Chunk result 1 for ${input}`,
+            source: 'doc1.txt',
+            score: 0.95,
+            chunkSignature: 'chunk-1'
+          },
+          {
+            text: `Chunk result 2 for ${input}`,
+            source: 'doc1.txt',
+            score: 0.88,
+            chunkSignature: 'chunk-2'
+          }
+        ]
+      };
+    }),
+
+    getPaginatedResults: vi.fn(async ({ requestId, page }: { requestId: string; page: number }) => {
+      const allResults = searches.get(requestId);
+      if (!allResults) {
+        throw new Error('Search not found');
+      }
+
+      const pageSize = 5;
+      const startIdx = (page - 1) * pageSize;
+      const results = allResults.slice(startIdx, startIdx + pageSize);
+      const hasMore = startIdx + pageSize < allResults.length;
+
+      return {
+        results,
+        pagination: {
+          total: allResults.length,
+          page,
+          pageSize,
+          hasMore
+        }
+      };
+    })
+  };
+
+  return mockSmartBucket;
+}
+
+describe('Search Bridge', () => {
+  describe('Basic Search', () => {
+    it('should perform search and return results', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "test query");
+        return {
+          count: results.results.length,
+          total: results.total,
+          hasMore: results.hasMore,
+          page: results.page,
+          pageSize: results.pageSize
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.count).toBe(5);
+      expect(result.result.total).toBe(12);
+      expect(result.result.hasMore).toBe(true);
+      expect(result.result.page).toBe(1);
+      expect(result.result.pageSize).toBe(5);
+    });
+
+    it('should return results with correct structure', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "test query");
+        const firstResult = results.results[0];
+        return {
+          hasText: typeof firstResult.text === 'string',
+          hasSource: typeof firstResult.source === 'string',
+          hasScore: typeof firstResult.score === 'number',
+          hasChunkSignature: typeof firstResult.chunkSignature === 'string'
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.hasText).toBe(true);
+      expect(result.result.hasSource).toBe(true);
+      expect(result.result.hasScore).toBe(true);
+      expect(result.result.hasChunkSignature).toBe(true);
+    });
+
+    it('should handle invalid mount path', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        try {
+          await search("/invalid/", "test");
+          return { error: false };
+        } catch (e) {
+          return { error: true, message: String(e) };
+        }
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.error).toBe(true);
+      expect(result.result.message).toContain('not found');
+    });
+  });
+
+  describe('Pagination', () => {
+    it('should navigate to next page', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const page1 = await search("/search/", "test query");
+        const page2 = await page1.nextPage();
+        return {
+          page1Count: page1.results.length,
+          page2Count: page2.results.length,
+          page2Page: page2.page,
+          page2HasMore: page2.hasMore
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.page1Count).toBe(5);
+      expect(result.result.page2Count).toBe(5);
+      expect(result.result.page2Page).toBe(2);
+      expect(result.result.page2HasMore).toBe(true);
+    });
+
+    it('should return empty results when no more pages', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const page1 = await search("/search/", "test query");
+        const page2 = await page1.nextPage();
+        const page3 = await page2.nextPage();
+        const page4 = await page3.nextPage();
+        return {
+          page3Count: page3.results.length,
+          page4Count: page4.results.length,
+          page4HasMore: page4.hasMore
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.page3Count).toBe(2); // Last page has 2 items
+      expect(result.result.page4Count).toBe(0);
+      expect(result.result.page4HasMore).toBe(false);
+    });
+
+    it('should paginate through all pages and iterate total results', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        let current = await search("/search/", "test query");
+        let total = 0;
+        while (current) {
+          total += current.results.length;
+          if (current.hasMore) {
+            current = await current.nextPage();
+          } else {
+            current = null;
+          }
+        }
+        return total;
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(12);
+    });
+  });
+
+  describe('Async Iterator', () => {
+    it('should support for-await iteration', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "test query");
+        let count = 0;
+        for await (const item of results) {
+          count++;
+        }
+        return count;
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result).toBe(12);
+    });
+
+    it('should iterate through all pages automatically', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "test query");
+        const texts = [];
+        for await (const item of results) {
+          texts.push(item.text);
+        }
+        return {
+          count: texts.length,
+          firstText: texts[0],
+          lastText: texts[texts.length - 1]
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.count).toBe(12);
+      expect(result.result.firstText).toContain('Result 1');
+      expect(result.result.lastText).toContain('Result 12');
+    });
+  });
+
+  describe('chunkSearch', () => {
+    it('should perform chunk search without pagination', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await chunkSearch("/search/", "rag query");
+        return {
+          count: results.results.length,
+          hasText: typeof results.results[0].text === 'string'
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.count).toBe(2);
+      expect(result.result.hasText).toBe(true);
+    });
+
+    it('should return chunk results with all expected fields', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await chunkSearch("/search/", "rag query");
+        const first = results.results[0];
+        return {
+          text: first.text,
+          source: first.source,
+          score: first.score,
+          chunkSignature: first.chunkSignature
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.text).toContain('Chunk result 1');
+      expect(result.result.source).toBe('doc1.txt');
+      expect(typeof result.result.score).toBe('number');
+      expect(result.result.chunkSignature).toBe('chunk-1');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty search results', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      // Override search to return empty results
+      mockSmartBucket.search = vi.fn(async () => ({
+        results: [],
+        pagination: {
+          total: 0,
+          page: 1,
+          pageSize: 5,
+          hasMore: false
+        }
+      }));
+
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "no results query");
+        return {
+          count: results.results.length,
+          hasMore: results.hasMore,
+          total: results.total
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.count).toBe(0);
+      expect(result.result.hasMore).toBe(false);
+      expect(result.result.total).toBe(0);
+    });
+
+    it('should handle single page of results', async () => {
+      const mockSmartBucket = createMockSmartBucket();
+      // Override search to return exactly one page
+      mockSmartBucket.search = vi.fn(async () => ({
+        results: [
+          {
+            text: 'Single result',
+            source: 'doc.txt',
+            score: 0.9,
+            chunkSignature: 'chunk-1'
+          }
+        ],
+        pagination: {
+          total: 1,
+          page: 1,
+          pageSize: 5,
+          hasMore: false
+        }
+      }));
+
+      mockSmartBucket.getPaginatedResults = vi.fn(async () => ({
+        results: [],
+        pagination: {
+          total: 1,
+          page: 2,
+          pageSize: 5,
+          hasMore: false
+        }
+      }));
+
+      const searchMounts = new Map<string, SearchMountInfo>([
+        ['search', { name: 'search', smartbucket: mockSmartBucket as any }]
+      ]);
+
+      const result = await executeWithAsyncHost(
+        `
+        const results = await search("/search/", "single result query");
+        const page2 = await results.nextPage();
+        return {
+          page1Count: results.results.length,
+          page1HasMore: results.hasMore,
+          page2Count: page2.results.length
+        };
+      `,
+        {},
+        {
+          bridgeInstallers: [ctx => installSearch(ctx, searchMounts)]
+        }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.result.page1Count).toBe(1);
+      expect(result.result.page1HasMore).toBe(false);
+      expect(result.result.page2Count).toBe(0);
+    });
+  });
+});