Spaces:
Running
Running
| import { act, cleanup, renderHook } from "@testing-library/react"; | |
| import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; | |
| import * as historyModule from "@/modules/history"; | |
| import { | |
| addSearchToHistory, | |
| historyDatabase, | |
| type SearchEntry, | |
| type TextResults, | |
| } from "@/modules/history"; | |
| import * as stringFormatters from "@/modules/stringFormatters"; | |
| import { | |
| FILTER_DEBOUNCE_MS, | |
| REFRESH_INTERVAL_MS, | |
| useSearchHistory, | |
| } from "./useSearchHistory"; | |
| vi.mock("@/modules/logEntries", () => ({ addLogEntry: vi.fn() })); | |
| // Pin auto-cleanup off so seeding is deterministic and pubSub's module-level | |
| // localStorage reads stay out of the test. | |
| vi.mock("@/modules/pubSub", () => ({ | |
| getSettings: vi.fn(() => ({ | |
| historyAutoCleanup: false, | |
| historyRetentionDays: 30, | |
| historyMaxEntries: 500, | |
| historyGroupByDate: false, | |
| })), | |
| })); | |
| const textResults: TextResults = { | |
| type: "text", | |
| items: [{ title: "t", url: "https://example.com/a", snippet: "s" }], | |
| }; | |
| // "weather in lisbon" is the narrowing-trap entry: "wet" matches nothing, | |
| // "weth" gains an insertion variant that matches it. | |
| const SEEDED_QUERIES = [ | |
| "weather in lisbon", | |
| "best pizza porto", | |
| "rust async tutorial", | |
| ]; | |
| const queriesOf = (entries: SearchEntry[]) => entries.map((e) => e.query); | |
| /** | |
| * Fake timers exclude setImmediate/clearImmediate so fake-indexeddb keeps its | |
| * real scheduling and DB reads resolve on the real event loop, while the | |
| * debounce and the 30s interval run on the fake clock. | |
| */ | |
| beforeEach(async () => { | |
| vi.useFakeTimers({ | |
| toFake: [ | |
| "setTimeout", | |
| "clearTimeout", | |
| "setInterval", | |
| "clearInterval", | |
| "Date", | |
| ], | |
| }); | |
| await historyDatabase.searches.clear(); | |
| await historyDatabase.llmResponses.clear(); | |
| await historyDatabase.chatHistory.clear(); | |
| for (const query of SEEDED_QUERIES) { | |
| await addSearchToHistory(query, textResults); | |
| // Distinct, deterministic timestamps so the orderBy(timestamp).reverse() | |
| // read order never falls back to a tie resolved by Dexie internals. | |
| vi.advanceTimersByTime(1000); | |
| } | |
| }); | |
| afterEach(async () => { | |
| cleanup(); | |
| await act(async () => {}); | |
| vi.useRealTimers(); | |
| vi.restoreAllMocks(); | |
| }); | |
| /** Let the debounce fire and any pending work flush. */ | |
| async function settle() { | |
| await act(async () => { | |
| await vi.advanceTimersByTimeAsync(FILTER_DEBOUNCE_MS + 50); | |
| }); | |
| } | |
| describe("useSearchHistory", () => { | |
| it("reads IndexedDB only on load, never while typing", async () => { | |
| const readSpy = vi.spyOn(historyModule, "getRecentSearches"); | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| expect(result.current.isLoading).toBe(false); | |
| expect(result.current.recentSearches).toHaveLength(SEEDED_QUERIES.length); | |
| const readsAfterLoad = readSpy.mock.calls.length; | |
| expect(readsAfterLoad).toBe(1); | |
| for (const query of ["w", "we", "wet", "weather"]) { | |
| act(() => result.current.searchHistory(query)); | |
| await settle(); | |
| } | |
| expect(readSpy).toHaveBeenCalledTimes(readsAfterLoad); | |
| // The filter did run: the settled query produced matches from memory. | |
| // "weather" is a stable prefix that always matches, so this test does not | |
| // depend on the uFuzzy narrowing trap. | |
| expect(queriesOf(result.current.filteredSearches)).toContain( | |
| "weather in lisbon", | |
| ); | |
| }); | |
| it("re-scans all in-memory entries per settled query instead of narrowing", async () => { | |
| // Assert the uFuzzy premise directly against the seeded entries first, so | |
| // a future @leeoniya/ufuzzy bump that changes the per-length error rules | |
| // fails here, pointing at the premise, not at the hook. | |
| const seeded = await historyDatabase.searches.toArray(); | |
| expect( | |
| stringFormatters.searchWithFuzzy(seeded, "wet", (entry) => entry.query), | |
| ).toHaveLength(0); | |
| expect( | |
| queriesOf( | |
| stringFormatters | |
| .searchWithFuzzy(seeded, "weth", (entry) => entry.query) | |
| .map((result) => result.item), | |
| ), | |
| ).toContain("weather in lisbon"); | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| // The trap: under this setup's per-length uFuzzy error rules, "wet" | |
| // compiles to a pattern that matches nothing. | |
| act(() => result.current.searchHistory("wet")); | |
| await settle(); | |
| expect(queriesOf(result.current.filteredSearches)).not.toContain( | |
| "weather in lisbon", | |
| ); | |
| // Typing past the prefix gains an insertion variant that matches. A fresh | |
| // full scan finds it; narrowing from the previous keystroke would have | |
| // kept it dropped forever. | |
| act(() => result.current.searchHistory("weth")); | |
| await settle(); | |
| expect(queriesOf(result.current.filteredSearches)).toContain( | |
| "weather in lisbon", | |
| ); | |
| }); | |
| it("runs one fuzzy pass per settled query, not one per keystroke", async () => { | |
| const fuzzySpy = vi.spyOn(stringFormatters, "searchWithFuzzy"); | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| expect(fuzzySpy).not.toHaveBeenCalled(); | |
| // A burst of keystrokes with no quiet period: nothing filters yet. | |
| act(() => { | |
| result.current.searchHistory("w"); | |
| result.current.searchHistory("we"); | |
| result.current.searchHistory("wet"); | |
| result.current.searchHistory("weth"); | |
| }); | |
| expect(fuzzySpy).not.toHaveBeenCalled(); | |
| await settle(); | |
| expect(fuzzySpy).toHaveBeenCalledTimes(1); | |
| expect(fuzzySpy.mock.calls[0][1]).toBe("weth"); | |
| }); | |
| it("keeps the 30s interval alive across keystrokes", async () => { | |
| const setIntervalSpy = vi.spyOn(globalThis, "setInterval"); | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| const intervalsAfterMount = setIntervalSpy.mock.calls.length; | |
| expect(intervalsAfterMount).toBe(1); | |
| for (const query of ["w", "we", "wet", "weth"]) { | |
| act(() => result.current.searchHistory(query)); | |
| await settle(); | |
| } | |
| expect(setIntervalSpy).toHaveBeenCalledTimes(intervalsAfterMount); | |
| }); | |
| it("still refreshes from IndexedDB when the 30s interval fires", async () => { | |
| const readSpy = vi.spyOn(historyModule, "getRecentSearches"); | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| expect(readSpy).toHaveBeenCalledTimes(1); | |
| act(() => result.current.searchHistory("weth")); | |
| await settle(); | |
| expect(readSpy).toHaveBeenCalledTimes(1); | |
| expect(result.current.filteredSearches).toHaveLength(1); | |
| expect(queriesOf(result.current.filteredSearches)).toContain( | |
| "weather in lisbon", | |
| ); | |
| await act(async () => { | |
| await vi.advanceTimersByTimeAsync(REFRESH_INTERVAL_MS + 50); | |
| }); | |
| expect(readSpy).toHaveBeenCalledTimes(2); | |
| // The active filter survives the background refresh: still one match, | |
| // not the full unfiltered list. | |
| expect(result.current.filteredSearches).toHaveLength(1); | |
| expect(queriesOf(result.current.filteredSearches)).toContain( | |
| "weather in lisbon", | |
| ); | |
| }); | |
| it("clearing the filter settles immediately, without waiting for the debounce", async () => { | |
| const { result } = renderHook(() => useSearchHistory({ limit: 100 })); | |
| await settle(); | |
| act(() => result.current.searchHistory("weth")); | |
| await settle(); | |
| expect(result.current.filteredSearches).toHaveLength(1); | |
| // The drawer's clear button: the full list must return on the same tick, | |
| // with no timer advance. | |
| act(() => result.current.searchHistory("")); | |
| expect(result.current.filteredSearches).toHaveLength(SEEDED_QUERIES.length); | |
| }); | |
| it("paginates from memory: page changes and queries trigger no reads", async () => { | |
| await addSearchToHistory("wine tasting porto", textResults); | |
| vi.advanceTimersByTime(1000); | |
| await addSearchToHistory("waterfall hike madeira", textResults); | |
| vi.advanceTimersByTime(1000); | |
| const readSpy = vi.spyOn(historyModule, "getRecentSearches"); | |
| const { result } = renderHook(() => | |
| useSearchHistory({ limit: 100, enablePagination: true, pageSize: 2 }), | |
| ); | |
| await settle(); | |
| expect(result.current.isLoading).toBe(false); | |
| expect(readSpy).toHaveBeenCalledTimes(1); | |
| expect(result.current.filteredSearches).toHaveLength(2); | |
| expect(result.current.totalPages).toBe(3); | |
| expect(result.current.hasNextPage).toBe(true); | |
| act(() => result.current.nextPage()); | |
| await settle(); | |
| expect(result.current.currentPage).toBe(1); | |
| expect(result.current.filteredSearches).toHaveLength(2); | |
| expect(readSpy).toHaveBeenCalledTimes(1); | |
| act(() => result.current.goToPage(0)); | |
| await settle(); | |
| act(() => result.current.searchHistory("w")); | |
| await settle(); | |
| // Three of the five seeded queries fuzzy-match "w"; the page shows the | |
| // top-ranked two of them, counted over the full match set. | |
| const wMatches = [ | |
| "weather in lisbon", | |
| "wine tasting porto", | |
| "waterfall hike madeira", | |
| ]; | |
| expect(result.current.totalPages).toBe(2); | |
| expect(result.current.filteredSearches).toHaveLength(2); | |
| expect(wMatches).toEqual( | |
| expect.arrayContaining(queriesOf(result.current.filteredSearches)), | |
| ); | |
| expect(readSpy).toHaveBeenCalledTimes(1); | |
| }); | |
| }); | |