@memberjunction/server 5.24.0 → 5.25.0

package/src/__tests__/search-knowledge-tags.test.ts

@@ -1,415 +1,255 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 /**
- * Tests for SearchKnowledgeResolver — focusing on tag enrichment,
- * title extraction, and metadata-to-result conversion logic.
+ * Tests for SearchKnowledgeResolver — the thin wrapper that delegates
+ * to SearchEngine.Instance.Search() and maps results to GraphQL types.
  *
- * The resolver has heavy infrastructure dependencies (type-graphql, vector DBs,
- * embeddings), so we test the pure-logic methods by constructing an instance
- * and accessing them via prototype / casting tricks.
+ * The actual search logic (providers, fusion, enrichment, permissions)
+ * is tested in the @memberjunction/search-engine package.
  */
 
 // ── Mocks ──────────────────────────────────────────────────────────────
 
-const mockRunViewResults = new Map<string, { Success: boolean; Results: unknown[] }>();
+const { mockSearch, mockPreviewSearch } = vi.hoisted(() => ({
+    mockSearch: vi.fn(),
+    mockPreviewSearch: vi.fn(),
+}));
 
-vi.mock('@memberjunction/core', () => {
-    class MockRunView {
-        async RunView(params: { EntityName: string; ExtraFilter?: string }): Promise<{ Success: boolean; Results: unknown[] }> {
-            // Allow tests to set up per-entity results
-            for (const [key, val] of mockRunViewResults.entries()) {
-                if (params.EntityName === key || (params.ExtraFilter && params.ExtraFilter.includes(key))) {
-                    return val;
-                }
-            }
-            return { Success: true, Results: [] };
+vi.mock('@memberjunction/search-engine', () => ({
+    SearchEngine: {
+        Instance: {
+            Config: vi.fn().mockResolvedValue(undefined),
+            Search: (...args: unknown[]) => mockSearch(...args),
+            PreviewSearch: (...args: unknown[]) => mockPreviewSearch(...args),
         }
     }
+}));
 
-    const mockEntities = [
-        {
-            Name: 'Contacts',
-            ID: 'entity-contacts-id',
-            Icon: 'fa-solid fa-user',
-            NameField: { Name: 'FullName', IsNameField: true, Sequence: 1 },
-            Fields: [
-                { Name: 'ID', IsNameField: false, IsPrimaryKey: true, Sequence: 0, TSType: 'string' },
-                { Name: 'FirstName', IsNameField: true, Sequence: 1, TSType: 'string', IsPrimaryKey: false },
-                { Name: 'LastName', IsNameField: true, Sequence: 2, TSType: 'string', IsPrimaryKey: false },
-                { Name: 'Email', IsNameField: false, Sequence: 3, TSType: 'string', IsPrimaryKey: false },
-            ]
-        },
-        {
-            Name: 'Companies',
-            ID: 'entity-companies-id',
-            Icon: 'fa-solid fa-building',
-            NameField: { Name: 'Name', IsNameField: true, Sequence: 1 },
-            Fields: [
-                { Name: 'ID', IsNameField: false, IsPrimaryKey: true, Sequence: 0, TSType: 'string' },
-                { Name: 'Name', IsNameField: true, Sequence: 1, TSType: 'string', IsPrimaryKey: false },
-            ]
-        },
-        {
-            Name: 'Events',
-            ID: 'entity-events-id',
-            Icon: null,
-            NameField: null,
-            Fields: [
-                { Name: 'ID', IsNameField: false, IsPrimaryKey: true, Sequence: 0, TSType: 'string' },
-                { Name: 'EventCode', IsNameField: false, Sequence: 1, TSType: 'number', IsPrimaryKey: false },
-            ]
-        }
-    ];
-
-    class MockMetadata {
-        Entities = mockEntities;
-    }
+vi.mock('@memberjunction/global', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>();
+    return { ...actual };
+});
 
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>();
     return {
-        RunView: MockRunView,
-        Metadata: MockMetadata,
+        ...actual,
         LogError: vi.fn(),
         LogStatus: vi.fn(),
-        UserInfo: class {},
-        ComputeRRF: vi.fn(),
-        ScoredCandidate: class {},
-        EntityRecordNameInput: class {},
-        CompositeKey: class { LoadFromURLSegment = vi.fn(); },
     };
 });
 
-vi.mock('@memberjunction/core-entities', () => ({
-    MJVectorIndexEntity: class {},
-    MJVectorDatabaseEntity: class {},
-    KnowledgeHubMetadataEngine: {
-        Instance: {
-            Config: vi.fn(),
-            ContentSourceTypes: [],
-            ContentSources: [],
-        },
-    },
-}));
-
-vi.mock('@memberjunction/ai', () => ({
-    GetAIAPIKey: vi.fn(() => 'mock-key'),
-    BaseEmbeddings: class {},
-}));
-
-vi.mock('@memberjunction/ai-vectordb', () => ({
-    VectorDBBase: class {},
-    BaseResponse: class {},
-}));
+vi.mock('@memberjunction/core-entities', async (importOriginal) => {
+    const actual = await importOriginal<Record<string, unknown>>();
+    return { ...actual };
+});
 
-vi.mock('@memberjunction/aiengine', () => ({
-    AIEngine: { Instance: { Config: vi.fn(), Models: [] } },
-}));
+// Mock type-graphql to avoid reflect-metadata dependency
+vi.mock('type-graphql', () => {
+    const noop = () => () => undefined;
+    const passthrough = () => (target: unknown) => target;
+    return {
+        Resolver: passthrough,
+        Mutation: noop,
+        Query: noop,
+        Subscription: noop,
+        Arg: noop,
+        Args: noop,
+        Ctx: noop,
+        ObjectType: passthrough,
+        InputType: passthrough,
+        ArgsType: passthrough,
+        Field: noop,
+        Float: Number,
+        Int: Number,
+        ID: String,
+        Authorized: noop,
+        PubSub: noop,
+        Root: noop,
+    };
+});
 
-vi.mock('@memberjunction/global', () => ({
-    MJGlobal: { Instance: { ClassFactory: { CreateInstance: vi.fn() } } },
-    UUIDsEqual: (a: string, b: string) => a?.toLowerCase() === b?.toLowerCase(),
-}));
+// ── Import after mocks ─────────────────────────────────────────────────
 
-vi.mock('type-graphql', () => ({
-    Resolver: () => (target: unknown) => target,
-    Query: () => (target: unknown, key: string, descriptor: PropertyDescriptor) => descriptor,
-    Mutation: () => (target: unknown, key: string, descriptor: PropertyDescriptor) => descriptor,
-    Arg: () => (target: unknown, key: string, index: number) => {},
-    Ctx: () => (target: unknown, key: string, index: number) => {},
-    ObjectType: () => (target: unknown) => target,
-    Field: () => (target: unknown, key: string) => {},
-    Float: Number,
-    Int: Number,
-    InputType: () => (target: unknown) => target,
-}));
+import { SearchKnowledgeResolver } from '../resolvers/SearchKnowledgeResolver.js';
 
-vi.mock('../generic/ResolverBase.js', () => ({
-    ResolverBase: class {
-        GetUserFromPayload() { return {}; }
-    },
-}));
+// ── Helpers ─────────────────────────────────────────────────────────────
 
-vi.mock('../types.js', () => ({
-    AppContext: class {},
-}));
+function createResolver(): SearchKnowledgeResolver {
+    const resolver = new SearchKnowledgeResolver();
+    // Mock GetUserFromPayload to return a fake user
+    (resolver as Record<string, unknown>)['GetUserFromPayload'] = vi.fn().mockReturnValue({
+        ID: 'test-user-id',
+        Email: 'test@test.com',
+        Name: 'Test User'
+    });
+    return resolver;
+}
 
-// ── Import under test (after mocks) ──────────────────────────────────
+function createMockSearchResult(overrides: Record<string, unknown> = {}) {
+    return {
+        Success: true,
+        Results: [
+            {
+                ID: 'result-1',
+                EntityName: 'Contacts',
+                RecordID: 'abc-123',
+                SourceType: 'entity',
+                ResultType: 'entity-record',
+                Title: 'John Smith',
+                Snippet: 'A contact record',
+                Score: 0.85,
+                ScoreBreakdown: { Entity: 0.85 },
+                Tags: ['VIP'],
+                EntityIcon: 'fa-solid fa-user',
+                RecordName: 'John Smith',
+                MatchedAt: new Date(),
+            }
+        ],
+        TotalCount: 1,
+        ElapsedMs: 42,
+        SourceCounts: { Vector: 0, FullText: 0, Entity: 1, Storage: 0 },
+        ...overrides
+    };
+}
 
-import { SearchKnowledgeResolver } from '../resolvers/SearchKnowledgeResolver.js';
+const fakeContext = { userPayload: { email: 'test@test.com' } };
 
-// Helper to access private methods
-function getPrivateMethod<T>(instance: T, method: string): (...args: unknown[]) => unknown {
-    return (instance as Record<string, unknown>)[method] as (...args: unknown[]) => unknown;
-}
+// ── Tests ───────────────────────────────────────────────────────────────
 
 describe('SearchKnowledgeResolver', () => {
-    let resolver: SearchKnowledgeResolver;
-
     beforeEach(() => {
-        resolver = new SearchKnowledgeResolver();
-        mockRunViewResults.clear();
+        vi.clearAllMocks();
     });
 
-    // ─── extractDisplayTitle ──────────────────────────────────────────
-
-    describe('extractDisplayTitle', () => {
-        const extractDisplayTitle = (meta: Record<string, unknown>, fallback: string) =>
-            getPrivateMethod(resolver, 'extractDisplayTitle')(meta, fallback) as string;
-
-        it('should combine multiple IsNameField values for a multi-name entity', () => {
-            const meta = { Entity: 'Contacts', FirstName: 'Sarah', LastName: 'Chen' };
-            const title = extractDisplayTitle(meta, 'Contacts');
-            expect(title).toBe('Sarah Chen');
-        });
+    describe('SearchKnowledge mutation', () => {
+        it('should delegate to SearchEngine.Instance.Search()', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-        it('should use single NameField when IsNameField fields are not populated', () => {
-            const meta = { Entity: 'Companies', Name: 'Acme Corp' };
-            const title = extractDisplayTitle(meta, 'Companies');
-            // Companies has Name as IsNameField, so it should use it
-            expect(title).toBe('Acme Corp');
-        });
+            const result = await resolver.SearchKnowledge('test query', 20, undefined, undefined, fakeContext as never);
 
-        it('should fall back to heuristic fields when no entity metadata matches', () => {
-            const meta = { Entity: 'UnknownEntity', Title: 'My Document' };
-            const title = extractDisplayTitle(meta, 'UnknownEntity');
-            expect(title).toBe('My Document');
+            expect(mockSearch).toHaveBeenCalledOnce();
+            expect(result.Success).toBe(true);
+            expect(result.TotalCount).toBe(1);
+            expect(result.Results).toHaveLength(1);
         });
 
-        it('should try Name heuristic field', () => {
-            const meta = { Entity: 'UnknownEntity', Name: 'Widget A' };
-            const title = extractDisplayTitle(meta, 'UnknownEntity');
-            expect(title).toBe('Widget A');
-        });
+        it('should pass query and maxResults to SearchEngine', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-        it('should try Subject heuristic field', () => {
-            const meta = { Entity: 'NonExistent', Subject: 'RE: Meeting' };
-            const title = extractDisplayTitle(meta, 'NonExistent');
-            expect(title).toBe('RE: Meeting');
-        });
+            await resolver.SearchKnowledge('cheese', 50, undefined, undefined, fakeContext as never);
 
-        it('should return fallback when no fields match', () => {
-            const meta = { Entity: 'Events', NumericCode: 42 };
-            const title = extractDisplayTitle(meta, 'Events');
-            expect(title).toBe('Events Record');
+            const searchParams = mockSearch.mock.calls[0][0];
+            expect(searchParams.Query).toBe('cheese');
+            expect(searchParams.MaxResults).toBe(50);
         });
 
-        it('should skip empty/whitespace name field values', () => {
-            const meta = { Entity: 'Contacts', FirstName: '', LastName: 'Rodriguez' };
-            const title = extractDisplayTitle(meta, 'Contacts');
-            expect(title).toBe('Rodriguez');
-        });
+        it('should pass filters when provided', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-        it('should handle metadata with no Entity key by using heuristics', () => {
-            const meta = { Name: 'Fallback Name' };
-            const title = extractDisplayTitle(meta, 'SomeEntity');
-            expect(title).toBe('Fallback Name');
-        });
+            const filters = { EntityNames: ['Contacts'], SourceTypes: undefined, Tags: ['VIP'] };
+            await resolver.SearchKnowledge('test', 20, filters as never, undefined, fakeContext as never);
 
-        it('should return fallback entity record string when all heuristic fields are non-string', () => {
-            const meta = { Entity: 'NonExistent', Count: 42, Active: true };
-            const title = extractDisplayTitle(meta, 'MyEntity');
-            expect(title).toBe('MyEntity Record');
+            const searchParams = mockSearch.mock.calls[0][0];
+            expect(searchParams.Filters).toEqual({
+                EntityNames: ['Contacts'],
+                SourceTypes: undefined,
+                Tags: ['VIP']
+            });
         });
-    });
 
-    // ─── extractDisplaySnippet ────────────────────────────────────────
+        it('should pass minScore when provided', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-    describe('extractDisplaySnippet', () => {
-        const extractDisplaySnippet = (meta: Record<string, unknown>, indexName: string, score?: number) =>
-            getPrivateMethod(resolver, 'extractDisplaySnippet')(meta, indexName, score) as string;
+            await resolver.SearchKnowledge('test', 20, undefined, 0.5, fakeContext as never);
 
-        it('should return Description field when present', () => {
-            const meta = { Description: 'A detailed description of the record' };
-            expect(extractDisplaySnippet(meta, 'idx-1', 0.95)).toBe('A detailed description of the record');
+            const searchParams = mockSearch.mock.calls[0][0];
+            expect(searchParams.MinScore).toBe(0.5);
         });
 
-        it('should truncate long descriptions to 200 chars', () => {
-            const longDesc = 'A'.repeat(250);
-            const meta = { Description: longDesc };
-            const snippet = extractDisplaySnippet(meta, 'idx-1');
-            expect(snippet.length).toBe(203); // 200 + '...'
-            expect(snippet.endsWith('...')).toBe(true);
-        });
+        it('should map result fields correctly', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult());
 
-        it('should build snippet from metadata fields when no description fields exist', () => {
-            const meta = { Status: 'Active', Type: 'Premium' };
-            const snippet = extractDisplaySnippet(meta, 'idx-1');
-            expect(snippet).toContain('Status: Active');
-            expect(snippet).toContain('Type: Premium');
-        });
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
 
-        it('should return index fallback when no usable metadata', () => {
-            const meta = { RecordID: 'abc-123', Entity: 'Contacts' };
-            const snippet = extractDisplaySnippet(meta, 'my-index', 0.85);
-            expect(snippet).toContain('my-index');
-            expect(snippet).toContain('0.8500');
+            const item = result.Results[0];
+            expect(item.ID).toBe('result-1');
+            expect(item.EntityName).toBe('Contacts');
+            expect(item.RecordID).toBe('abc-123');
+            expect(item.Title).toBe('John Smith');
+            expect(item.Score).toBe(0.85);
+            expect(item.Tags).toEqual(['VIP']);
+            expect(item.EntityIcon).toBe('fa-solid fa-user');
         });
-    });
 
-    // ─── Tag extraction from vector metadata (inline logic) ────────
+        it('should map source counts correctly', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult({
+                SourceCounts: { Vector: 5, FullText: 3, Entity: 10, Storage: 0 }
+            }));
 
-    describe('tag extraction from vector metadata', () => {
-        it('should extract Tags array when present and is an array', () => {
-            const meta: Record<string, unknown> = { Tags: ['AI', 'Machine Learning'] };
-            const tags = Array.isArray(meta['Tags']) ? (meta['Tags'] as string[]) : [];
-            expect(tags).toEqual(['AI', 'Machine Learning']);
-        });
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
 
-        it('should return empty array when Tags is not in metadata', () => {
-            const meta: Record<string, unknown> = { Entity: 'Companies', RecordID: 'r2' };
-            const tags = Array.isArray(meta['Tags']) ? (meta['Tags'] as string[]) : [];
-            expect(tags).toEqual([]);
+            expect(result.SourceCounts.Vector).toBe(5);
+            expect(result.SourceCounts.FullText).toBe(3);
+            expect(result.SourceCounts.Entity).toBe(10);
         });
 
-        it('should return empty array when Tags is not an array', () => {
-            const meta: Record<string, unknown> = { Tags: 'not-an-array' };
-            const tags = Array.isArray(meta['Tags']) ? (meta['Tags'] as string[]) : [];
-            expect(tags).toEqual([]);
-        });
-
-        it('should return empty array when metadata is empty', () => {
-            const meta: Record<string, unknown> = {};
-            const tags = Array.isArray(meta['Tags']) ? (meta['Tags'] as string[]) : [];
-            expect(tags).toEqual([]);
-        });
-    });
+        it('should pass empty query through to SearchEngine (validation happens there)', async () => {
+            const resolver = createResolver();
+            mockSearch.mockResolvedValueOnce(createMockSearchResult({ Success: false, ErrorMessage: 'Query cannot be empty' }));
 
-    // ─── enrichResultsWithTags ────────────────────────────────────────
+            const result = await resolver.SearchKnowledge('   ', 20, undefined, undefined, fakeContext as never);
 
-    describe('enrichResultsWithTags', () => {
-        const enrichResultsWithTags = (
-            results: Array<{ EntityName: string; RecordID: string; Tags: string[] }>,
-            md: { Entities: Array<{ Name: string; ID: string }> },
-            contextUser: unknown
-        ) => getPrivateMethod(resolver, 'enrichResultsWithTags')(results, md, contextUser) as Promise<void>;
-
-        it('should not modify results when results array is empty', async () => {
-            const results: Array<{ EntityName: string; RecordID: string; Tags: string[] }> = [];
-            const md = { Entities: [{ Name: 'Contacts', ID: 'eid-1' }] };
-            await enrichResultsWithTags(results, md, {});
-            expect(results).toEqual([]);
+            expect(mockSearch).toHaveBeenCalled();
+            expect(result.Success).toBe(false);
         });
 
-        it('should not modify results when entity is not found in metadata', async () => {
-            const results = [{ EntityName: 'NonExistent', RecordID: 'r1', Tags: [] as string[] }];
-            const md = { Entities: [{ Name: 'Contacts', ID: 'eid-1' }] };
-            await enrichResultsWithTags(results, md, {});
-            expect(results[0].Tags).toEqual([]);
-        });
+        it('should return error when user cannot be determined', async () => {
+            const resolver = new SearchKnowledgeResolver();
+            (resolver as Record<string, unknown>)['GetUserFromPayload'] = vi.fn().mockReturnValue(null);
 
-        it('should enrich results with tags from RunView response', async () => {
-            const results = [
-                { EntityName: 'Contacts', RecordID: 'rec-1', Tags: [] as string[] },
-                { EntityName: 'Contacts', RecordID: 'rec-2', Tags: [] as string[] },
-            ];
-
-            // Set up mock RunView to return tagged items
-            // loadTaggedItemTags queries 'MJ: Tagged Items' with EntityID+RecordID filter
-            mockRunViewResults.set('MJ: Tagged Items', {
-                Success: true,
-                Results: [
-                    { EntityID: 'entity-contacts-id', RecordID: 'rec-1', Tag: 'VIP' },
-                    { EntityID: 'entity-contacts-id', RecordID: 'rec-1', Tag: 'Partner' },
-                    { EntityID: 'entity-contacts-id', RecordID: 'rec-2', Tag: 'Prospect' },
-                ]
-            });
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
 
-            // Test loadTaggedItemTags directly since enrichResultsWithTags wraps it in try/catch
-            const loadTaggedItemTags = getPrivateMethod(resolver, 'loadTaggedItemTags');
-            const { Metadata: MetadataCtor } = await import('@memberjunction/core');
-            const md = new MetadataCtor();
-            await loadTaggedItemTags(results, md, {});
-            expect(results[0].Tags).toEqual(['VIP', 'Partner']);
-            expect(results[1].Tags).toEqual(['Prospect']);
+            expect(result.Success).toBe(false);
+            expect(result.ErrorMessage).toContain('current user');
         });
 
-        it('should leave existing tags unchanged when RunView fails', async () => {
-            const results = [
-                { EntityName: 'Contacts', RecordID: 'rec-1', Tags: ['Existing'] },
-            ];
-            const md = { Entities: [{ Name: 'Contacts', ID: 'eid-contacts' }] };
+        it('should handle SearchEngine errors gracefully', async () => {
+            const resolver = createResolver();
+            mockSearch.mockRejectedValueOnce(new Error('Connection failed'));
 
-            mockRunViewResults.set('MJ: Tagged Items', {
-                Success: false,
-                Results: []
-            });
+            const result = await resolver.SearchKnowledge('test', 20, undefined, undefined, fakeContext as never);
 
-            // enrichResultsWithTags replaces Tags; on RunView failure it returns early
-            await enrichResultsWithTags(results, md, {});
-            // Tags should remain unchanged since RunView failed before tag assignment
-            expect(results[0].Tags).toEqual(['Existing']);
+            expect(result.Success).toBe(false);
+            expect(result.ErrorMessage).toContain('Connection failed');
         });
     });
 
-    // ─── deduplicateResults ───────────────────────────────────────────
-
-    describe('deduplicateResults', () => {
-        const deduplicateResults = (results: Array<{ EntityName: string; RecordID: string; Score: number }>) =>
-            getPrivateMethod(resolver, 'deduplicateResults')(results) as Array<{ EntityName: string; RecordID: string; Score: number }>;
-
-        it('should keep the highest-scored entry for duplicate entity+recordID', () => {
-            const results = [
-                { EntityName: 'Contacts', RecordID: 'r1', Score: 0.8 },
-                { EntityName: 'Contacts', RecordID: 'r1', Score: 0.95 },
-                { EntityName: 'Contacts', RecordID: 'r1', Score: 0.7 },
-            ];
-            const deduped = deduplicateResults(results);
-            expect(deduped).toHaveLength(1);
-            expect(deduped[0].Score).toBe(0.95);
-        });
+    describe('PreviewSearch mutation', () => {
+        it('should delegate to SearchEngine.Instance.PreviewSearch()', async () => {
+            const resolver = createResolver();
+            mockPreviewSearch.mockResolvedValueOnce(createMockSearchResult());
 
-        it('should keep distinct records from different entities', () => {
-            const results = [
-                { EntityName: 'Contacts', RecordID: 'r1', Score: 0.8 },
-                { EntityName: 'Companies', RecordID: 'r1', Score: 0.7 },
-            ];
-            const deduped = deduplicateResults(results);
-            expect(deduped).toHaveLength(2);
-        });
-
-        it('should sort results by score descending', () => {
-            const results = [
-                { EntityName: 'A', RecordID: 'r1', Score: 0.3 },
-                { EntityName: 'B', RecordID: 'r2', Score: 0.9 },
-                { EntityName: 'C', RecordID: 'r3', Score: 0.6 },
-            ];
-            const deduped = deduplicateResults(results);
-            expect(deduped[0].Score).toBe(0.9);
-            expect(deduped[1].Score).toBe(0.6);
-            expect(deduped[2].Score).toBe(0.3);
-        });
+            const result = await resolver.PreviewSearch('test', 8, fakeContext as never);
 
-        it('should return empty array for empty input', () => {
-            expect(deduplicateResults([])).toEqual([]);
+            expect(mockPreviewSearch).toHaveBeenCalledOnce();
+            expect(mockPreviewSearch).toHaveBeenCalledWith('test', 8, expect.anything());
+            expect(result.Success).toBe(true);
         });
-    });
 
-    // ─── buildPineconeFilter ──────────────────────────────────────────
+        it('should default maxResults to 8', async () => {
+            const resolver = createResolver();
+            mockPreviewSearch.mockResolvedValueOnce(createMockSearchResult());
 
-    describe('buildPineconeFilter', () => {
-        const buildPineconeFilter = (filters?: { EntityNames?: string[]; SourceTypes?: string[]; Tags?: string[] }) =>
-            getPrivateMethod(resolver, 'buildPineconeFilter')(filters) as object | undefined;
+            await resolver.PreviewSearch('test', 8, fakeContext as never);
 
-        it('should return undefined for no filters', () => {
-            expect(buildPineconeFilter(undefined)).toBeUndefined();
-        });
-
-        it('should return undefined for empty filters', () => {
-            expect(buildPineconeFilter({})).toBeUndefined();
-        });
-
-        it('should return single condition without $and wrapper', () => {
-            const result = buildPineconeFilter({ EntityNames: ['Contacts'] });
-            expect(result).toEqual({ Entity: { $in: ['Contacts'] } });
-        });
-
-        it('should combine multiple filters with $and', () => {
-            const result = buildPineconeFilter({
-                EntityNames: ['Contacts'],
-                Tags: ['VIP']
-            }) as Record<string, unknown>;
-            expect(result).toHaveProperty('$and');
-            const conditions = result['$and'] as object[];
-            expect(conditions).toHaveLength(2);
+            expect(mockPreviewSearch).toHaveBeenCalledWith('test', 8, expect.anything());
         });
     });
 });