Files
OllaHub/lib/web-search-fallback.test.ts
T

185 lines
9.1 KiB
TypeScript

import Module from 'node:module';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { invoke } from '@tauri-apps/api/core';
import { executeProgressiveSearch } from './web-search-fallback';
import * as relevanceScorer from './relevance-scorer';
import type { ScrapedContent } from '@/services/webSearch';
import type { QueryContext } from './contextual-analyzer';
vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn(async () => undefined) }));
const QUERY = 'energia solar residencial';
function page(id: string | number, relevant = true): ScrapedContent {
return relevant
? { title: `Energia solar residencial ${id}`, url: `https://ex.com/${id}`, content: '', markdown: `energia solar residencial ${'x'.repeat(120)}` }
: { title: `nada ${id}`, url: `https://ex.com/${id}`, content: '', markdown: '' };
}
const pages = (n: number, relevant = true, prefix = 'p') => Array.from({ length: n }, (_, i) => page(`${prefix}${i}`, relevant));
// Fake do Ollama para expandQuery (rodadas > 1 no modo tradicional).
function stubExpansion(response: string) {
const fetchMock = vi.fn(async () => ({ ok: true, json: async () => ({ response }) }) as Response);
vi.stubGlobal('fetch', fetchMock);
return fetchMock;
}
function logged(text: string) {
return vi.mocked(invoke).mock.calls.some(
([cmd, args]) => cmd === 'log_to_terminal' && !!args && 'message' in args && String(args.message).includes(text),
);
}
describe('executeProgressiveSearch', () => {
beforeEach(() => {
vi.mocked(invoke).mockClear();
stubExpansion('');
});
it('1ª rodada com 5 resultados relevantes: early exit com sucesso', async () => {
const searchFn = vi.fn(async () => pages(5));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm');
expect(r).toMatchObject({ success: true, usedFallback: false, totalResultsAnalyzed: 5, finalQuery: QUERY });
expect(r.attempts).toHaveLength(1);
expect(r.attempts[0]).toMatchObject({ round: 1, strategy: 'literal', query: QUERY, queries: undefined, relevanceScore: 1 });
expect(searchFn).toHaveBeenCalledWith(QUERY, 10, 1);
});
it('modo semântico: rodadas por estratégia, sem expansão, várias queries por rodada', async () => {
const fetchMock = stubExpansion('nao deveria');
const searchFn = vi.fn(async (q: string) => [page(q)]);
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', {
useSemanticSearch: true,
enrichedQueries: { literal: ['a'], semantic: ['b'], related: ['c'], expanded: [], contextual: [] },
});
expect(r.attempts.map((a) => [a.strategy, a.queries ?? a.query])).toEqual([
['literal', ['a', 'b']],
['related', 'c'],
]);
expect(fetchMock).not.toHaveBeenCalled();
expect(r.success).toBe(false);
});
it('semântico ligado sem enrichedQueries: cai no modo tradicional', async () => {
const searchFn = vi.fn(async () => []);
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { useSemanticSearch: true, maxRounds: 2 });
expect(r.attempts.map((a) => a.strategy)).toEqual(['literal', 'literal']);
});
it('nenhum resultado em todas as rodadas: fallback com maxRounds tentativas', async () => {
const r = await executeProgressiveSearch(QUERY, vi.fn(async () => []), 'm', { maxRounds: 3, enableQueryExpansion: false });
expect(r).toMatchObject({ success: false, usedFallback: true, totalResultsAnalyzed: 0, scrapedSources: [] });
expect(r.attempts).toHaveLength(3);
expect(r.attempts[0].relevanceScore).toBe(0);
});
it('tempo total da query esgotado antes da 1ª rodada: nenhuma busca', async () => {
let t = 0;
vi.spyOn(Date, 'now').mockImplementation(() => (t += 30_000));
const searchFn = vi.fn(async () => pages(5));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm');
expect(searchFn).not.toHaveBeenCalled();
expect(r).toMatchObject({ success: false, attempts: [] });
});
it('maxTimeoutPerQuery 0: usa o padrão de 25s em vez de parar na hora', async () => {
let t = 0;
vi.spyOn(Date, 'now').mockImplementation(() => (t += 1_000));
const searchFn = vi.fn(async () => pages(5));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { maxTimeoutPerQuery: 0 });
expect(r.success).toBe(true);
});
it('2ª rodada tradicional: expande a query pelo Ollama', async () => {
const fetchMock = stubExpansion('"painel solar para casa."');
const searchFn = vi.fn(async (_q: string) => [] as ScrapedContent[]);
await executeProgressiveSearch(QUERY, searchFn, 'm', { maxRounds: 2 });
expect(searchFn.mock.calls.map((c) => c[0])).toEqual([QUERY, 'painel solar para casa']);
expect(fetchMock).toHaveBeenCalledTimes(1);
});
it('expansão desligada: 2ª rodada repete a query original', async () => {
const fetchMock = stubExpansion('outra coisa');
const searchFn = vi.fn(async (_q: string) => [] as ScrapedContent[]);
await executeProgressiveSearch(QUERY, searchFn, 'm', { maxRounds: 2, enableQueryExpansion: false });
expect(searchFn.mock.calls.map((c) => c[0])).toEqual([QUERY, QUERY]);
expect(fetchMock).not.toHaveBeenCalled();
});
it('searchFn lança: rodada vazia e segue para a próxima', async () => {
const searchFn = vi.fn()
.mockRejectedValueOnce(new Error('motor caiu'))
.mockResolvedValueOnce(pages(5));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { enableQueryExpansion: false });
expect(r.success).toBe(true);
expect(r.attempts.map((a) => a.results.length)).toEqual([0, 5]);
});
it('timeout da rodada: usa o que já chegou sem esperar a query travada', async () => {
const searchFn = vi.fn(async (q: string) => (q === 'trava' ? new Promise<ScrapedContent[]>(() => {}) : [page('ok')]));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', {
useSemanticSearch: true,
enrichedQueries: { literal: ['rapida', 'trava'], semantic: [], related: [], expanded: [], contextual: [] },
maxTimeoutPerRound: 50,
});
expect(r.attempts).toHaveLength(1);
expect(r.attempts[0].results.map((p) => p.url)).toEqual(['https://ex.com/ok']);
expect(r.attempts[0].query).toBe('rapida');
}, 2_000);
it('timeout da rodada sem nenhuma query concluída: registra a query original', async () => {
const searchFn = vi.fn(() => new Promise<ScrapedContent[]>(() => {}));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { maxRounds: 1, maxTimeoutPerRound: 20 });
expect(r.attempts[0]).toMatchObject({ query: QUERY, results: [] });
}, 2_000);
it('URL repetida entre rodadas: conta só uma vez', async () => {
const searchFn = vi.fn(async () => [page('mesma', false)]);
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { maxRounds: 2, enableQueryExpansion: false });
expect(r.attempts.map((a) => a.results.length)).toEqual([1, 0]);
expect(r.scrapedSources).toHaveLength(1);
});
it('mais de 3 resultados numa rodada: registra quantos sobraram no log', async () => {
await executeProgressiveSearch(QUERY, vi.fn(async () => pages(5, false)), 'm', { maxRounds: 1 });
expect(logged('... and 2 more results')).toBe(true);
});
it('até 3 resultados numa rodada: sem a linha de excedentes', async () => {
await executeProgressiveSearch(QUERY, vi.fn(async () => pages(3, false)), 'm', { maxRounds: 1 });
expect(logged('more results')).toBe(false);
});
it('com contexto: relevância vem de calculateSemanticSimilarity', async () => {
// Em produção o webpack resolve este require; o require do Node não carrega .ts sem extensão.
const nodeRequire = Module.prototype.require;
vi.spyOn(Module.prototype, 'require').mockImplementation(function (this: NodeJS.Module, id: string) {
return id === './relevance-scorer' ? relevanceScorer : nodeRequire.call(this, id);
} as typeof nodeRequire);
const context = { keywords: ['inexistente'], entities: [], topics: [], synonyms: [] } as unknown as QueryContext;
const r = await executeProgressiveSearch(QUERY, vi.fn(async () => pages(5)), 'm', { context, maxRounds: 1 });
// Pela heurística sem contexto o score seria 1 (early exit); com contexto a keyword não casa.
expect(r.attempts[0].relevanceScore).toBe(0);
expect(r.success).toBe(false);
});
it('5+ resultados com relevância baixa: não sai cedo', async () => {
const r = await executeProgressiveSearch(QUERY, vi.fn(async () => pages(6, false)), 'm', { maxRounds: 1 });
expect(r).toMatchObject({ success: false, usedFallback: true, totalResultsAnalyzed: 6 });
});
it('minResultsForEarlyExit e minRelevanceForEarlyExit configurados: sai com 1 resultado', async () => {
const r = await executeProgressiveSearch(QUERY, vi.fn(async () => [page(1)]), 'm', { minResultsForEarlyExit: 1, minRelevanceForEarlyExit: 0.9 });
expect(r.success).toBe(true);
});
it('atingiu maxTotalResults: para antes das rodadas restantes', async () => {
let n = 0;
const searchFn = vi.fn(async () => pages(4, false, `r${n++}-`));
const r = await executeProgressiveSearch(QUERY, searchFn, 'm', { maxTotalResults: 6, maxRounds: 4, enableQueryExpansion: false });
expect(r.attempts).toHaveLength(2);
expect(r).toMatchObject({ success: false, totalResultsAnalyzed: 8 });
});
});