import { describe, it, expect } from "vitest"; import { composeSearchGroups, DEFAULT_GROUP_ORDER, groupsForScope, isSearchRoute, moveGroup, normalizeGroupOrder, parseSearchScope, reorderGroups, resolveSearchScope, searchRouteUrl, seedFromSearchUrl, shouldNavigateToSearch, type SearchGroupId, } from "./searchScope"; describe("resolveSearchScope", () => { it("scopes music routes to music", () => { expect(resolveSearchScope("/library/music")).toBe("music"); expect(resolveSearchScope("/library/music/albums")).toBe("music"); expect(resolveSearchScope("/library/music/artists")).toBe("music"); expect(resolveSearchScope("/library/music/genres")).toBe("music"); expect(resolveSearchScope("/library/music/playlists")).toBe("music"); expect(resolveSearchScope("/library/music/tracks")).toBe("music"); }); it("scopes movie routes to movies", () => { expect(resolveSearchScope("/library/movies")).toBe("movies"); expect(resolveSearchScope("/library/movies/all")).toBe("movies"); expect(resolveSearchScope("/library/movies/genres")).toBe("movies"); }); it("scopes tv routes to tv", () => { expect(resolveSearchScope("/library/tv")).toBe("tv"); expect(resolveSearchScope("/library/tv/shows")).toBe("tv"); }); it("treats /library/shows as tv", () => { // The TV genre page lives under `shows`, not `tv`. expect(resolveSearchScope("/library/shows/genres")).toBe("tv"); expect(resolveSearchScope("/library/shows")).toBe("tv"); }); it("falls back to all for home, library root, search and unknown routes", () => { expect(resolveSearchScope("/")).toBe("all"); expect(resolveSearchScope("/library")).toBe("all"); expect(resolveSearchScope("/search")).toBe("all"); expect(resolveSearchScope("/settings")).toBe("all"); expect(resolveSearchScope("/downloads")).toBe("all"); expect(resolveSearchScope("/library/abc123")).toBe("all"); expect(resolveSearchScope("/nonsense/route")).toBe("all"); }); it("tolerates trailing slashes, query strings and hashes", () => { expect(resolveSearchScope("/library/music/")).toBe("music"); expect(resolveSearchScope("/library/tv?foo=1")).toBe("tv"); expect(resolveSearchScope("/library/movies#top")).toBe("movies"); expect(resolveSearchScope("")).toBe("all"); }); it("does not match a prefix that is only a partial segment", () => { expect(resolveSearchScope("/library/musicvideos")).toBe("all"); }); }); // NOTE: the former `scopeItemTypes` suite moved to Rust — see // `search_scope_tests` in src-tauri/src/repository/types.rs. The scope → // item-type expansion is domain vocabulary and is no longer reachable from the // frontend, so testing it here would mean re-introducing the leak to test it. // The "fresh array" test is gone because `item_types()` returns an owned Vec, // making the aliasing bug it guarded structurally impossible. describe("normalizeGroupOrder", () => { it("returns the default for missing or non-array input", () => { expect(normalizeGroupOrder(null)).toEqual([...DEFAULT_GROUP_ORDER]); expect(normalizeGroupOrder(undefined)).toEqual([...DEFAULT_GROUP_ORDER]); expect(normalizeGroupOrder("nonsense")).toEqual([...DEFAULT_GROUP_ORDER]); expect(normalizeGroupOrder({})).toEqual([...DEFAULT_GROUP_ORDER]); }); it("drops ids that no longer exist", () => { expect(normalizeGroupOrder(["movies", "podcasts", "songs"])).toEqual([ "movies", "songs", "shows", "episodes", "albums", "artists", "people", ]); }); it("appends groups a stored order does not mention", () => { // A user upgrading from a build with fewer groups must not lose the new ones. expect(normalizeGroupOrder(["movies", "songs"])).toEqual([ "movies", "songs", "shows", "episodes", "albums", "artists", "people", ]); }); it("de-duplicates repeated ids", () => { expect(normalizeGroupOrder(["songs", "songs", "movies"])).toEqual([ "songs", "movies", "shows", "episodes", "albums", "artists", "people", ]); }); it("preserves a complete valid order unchanged", () => { const order: SearchGroupId[] = [ "episodes", "shows", "movies", "artists", "albums", "songs", "people", ]; expect(normalizeGroupOrder(order)).toEqual(order); }); it("expands a stored `tvShows` into shows + episodes in place", () => { // Migration: the old combined group split, and a user who put TV first // must still get TV first rather than appended at the bottom. expect(normalizeGroupOrder(["tvShows", "movies"])).toEqual([ "shows", "episodes", "movies", "songs", "albums", "artists", "people", ]); }); }); describe("groupsForScope", () => { it("returns every group in saved order for the all scope", () => { expect( groupsForScope("all", [ "movies", "songs", "shows", "episodes", "albums", "artists", "people", ]) ).toEqual(["movies", "songs", "shows", "episodes", "albums", "artists", "people"]); }); it("keeps only in-scope groups, in saved order", () => { const order: SearchGroupId[] = [ "artists", "movies", "albums", "episodes", "shows", "songs", "people", ]; expect(groupsForScope("music", order)).toEqual(["artists", "albums", "songs"]); expect(groupsForScope("movies", order)).toEqual(["movies"]); expect(groupsForScope("tv", order)).toEqual(["episodes", "shows"]); }); it("surfaces people only under the all scope", () => { // Cast/crew cut across music, film and TV, so no narrow scope claims them. expect(groupsForScope("all", DEFAULT_GROUP_ORDER)).toContain("people"); expect(groupsForScope("music", DEFAULT_GROUP_ORDER)).not.toContain("people"); expect(groupsForScope("tv", DEFAULT_GROUP_ORDER)).not.toContain("people"); expect(groupsForScope("movies", DEFAULT_GROUP_ORDER)).not.toContain("people"); }); }); describe("composeSearchGroups", () => { const results = [ { id: "1", type: "Audio" }, { id: "2", type: "MusicAlbum" }, { id: "3", type: "Movie" }, { id: "4", type: "Series" }, { id: "5", type: "Episode" }, { id: "6", type: "Person" }, ]; it("renders groups in the configured order", () => { const groups = composeSearchGroups(results, "all", [ "shows", "episodes", "movies", "songs", "albums", "artists", "people", ]); expect(groups.map((g) => g.id)).toEqual([ "shows", "episodes", "movies", "songs", "albums", "people", ]); }); it("puts shows ahead of episodes by default", () => { // Searching a show's name should surface the show itself first, not an // arbitrary episode of it. const ids = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id); expect(ids).toEqual(["shows", "episodes"]); }); it("omits empty groups", () => { // No artists in the fixture, so the artists group never renders. const groups = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER); expect(groups.map((g) => g.id)).not.toContain("artists"); }); it("drops out-of-scope groups", () => { expect(composeSearchGroups(results, "music", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([ "songs", "albums", ]); expect(composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER).map((g) => g.id)).toEqual([ "shows", "episodes", ]); }); it("separates series and episodes into their own groups", () => { const groups = composeSearchGroups(results, "tv", DEFAULT_GROUP_ORDER); expect(groups.find((g) => g.id === "shows")?.items.map((i) => i.id)).toEqual(["4"]); expect(groups.find((g) => g.id === "episodes")?.items.map((i) => i.id)).toEqual(["5"]); }); it("surfaces people so an actor search reaches their bio", () => { // Person items were previously returned by the backend and silently dropped. const all = composeSearchGroups(results, "all", DEFAULT_GROUP_ORDER); expect(all.find((g) => g.id === "people")?.items.map((i) => i.id)).toEqual(["6"]); }); it("ignores item types that belong to no group", () => { const withFolder = [...results, { id: "7", type: "CollectionFolder" }]; const all = composeSearchGroups(withFolder, "all", DEFAULT_GROUP_ORDER); expect(all.flatMap((g) => g.items).map((i) => i.id)).not.toContain("7"); }); it("narrowing then widening restores the full arrangement", () => { // Scope is a filter over the saved order, never a rewrite of it. const order: SearchGroupId[] = [ "shows", "songs", "movies", "albums", "artists", "episodes", "people", ]; const wide = composeSearchGroups(results, "all", order).map((g) => g.id); composeSearchGroups(results, "music", order); expect(composeSearchGroups(results, "all", order).map((g) => g.id)).toEqual(wide); expect(wide).toEqual(["shows", "songs", "movies", "albums", "episodes", "people"]); }); it("survives a stored order containing an unknown id", () => { const groups = composeSearchGroups(results, "all", [ "podcasts", "movies", ] as unknown as SearchGroupId[]); expect(groups.map((g) => g.id)).toEqual([ "movies", "shows", "episodes", "songs", "albums", "people", ]); }); it("handles items with a missing type", () => { const groups = composeSearchGroups( [{ id: "x", type: null }, { id: "y" }] as { id: string; type?: string | null }[], "all", DEFAULT_GROUP_ORDER ); expect(groups).toEqual([]); }); }); describe("moveGroup", () => { const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "shows"]; it("moves a group up", () => { expect(moveGroup(order, "artists", -1)).toEqual([ "songs", "artists", "albums", "movies", "shows", ]); }); it("moves a group down", () => { expect(moveGroup(order, "songs", 1)).toEqual([ "albums", "songs", "artists", "movies", "shows", ]); }); it("is a no-op at the boundaries", () => { expect(moveGroup(order, "songs", -1)).toEqual(order); expect(moveGroup(order, "shows", 1)).toEqual(order); }); it("is a no-op for an unknown id", () => { expect(moveGroup(order, "podcasts" as SearchGroupId, 1)).toEqual(order); }); it("does not mutate the input", () => { const input = [...order]; moveGroup(input, "songs", 1); expect(input).toEqual(order); }); }); describe("reorderGroups", () => { const order: SearchGroupId[] = ["songs", "albums", "artists", "movies", "shows"]; it("moves an item from one index to another", () => { expect(reorderGroups(order, 0, 4)).toEqual([ "albums", "artists", "movies", "shows", "songs", ]); expect(reorderGroups(order, 4, 0)).toEqual([ "shows", "songs", "albums", "artists", "movies", ]); }); it("is a no-op for equal or out-of-range indices", () => { expect(reorderGroups(order, 2, 2)).toEqual(order); expect(reorderGroups(order, -1, 2)).toEqual(order); expect(reorderGroups(order, 0, 9)).toEqual(order); }); }); describe("searchRouteUrl", () => { it("encodes the query and the scope", () => { expect(searchRouteUrl("miles davis", "music")).toBe("/search?q=miles%20davis&scope=music"); }); it("omits the scope key for the default `all` scope", () => { expect(searchRouteUrl("dune", "all")).toBe("/search?q=dune"); }); it("targets bare /search for an empty query so the page shows its empty state", () => { expect(searchRouteUrl("", "all")).toBe("/search"); expect(searchRouteUrl(" ", "music")).toBe("/search"); }); }); describe("shouldNavigateToSearch", () => { it("navigates from any library page, which cannot render results itself", () => { // The bug: the header search bar shows on every /library/** route but only // /library rendered $library.searchResults, so typing did nothing on // /library/music, /library/tv, /library/movies and detail pages. expect(shouldNavigateToSearch("/library", "jazz")).toBe(true); expect(shouldNavigateToSearch("/library/music", "jazz")).toBe(true); expect(shouldNavigateToSearch("/library/tv", "jazz")).toBe(true); expect(shouldNavigateToSearch("/library/movies", "jazz")).toBe(true); expect(shouldNavigateToSearch("/library/abc123", "jazz")).toBe(true); }); it("stays put when already on /search, so typing does not re-push history", () => { expect(shouldNavigateToSearch("/search", "jazz")).toBe(false); expect(shouldNavigateToSearch("/search?q=old", "jazz")).toBe(false); }); it("does not navigate on an empty query", () => { expect(shouldNavigateToSearch("/library/music", "")).toBe(false); expect(shouldNavigateToSearch("/library/music", " ")).toBe(false); }); }); describe("isSearchRoute", () => { it("recognises the search surface through query strings and trailing slashes", () => { expect(isSearchRoute("/search")).toBe(true); expect(isSearchRoute("/search/")).toBe(true); expect(isSearchRoute("/search?q=jazz&scope=music")).toBe(true); expect(isSearchRoute("/library/music")).toBe(false); expect(isSearchRoute("/")).toBe(false); }); }); describe("parseSearchScope", () => { it("accepts the known scopes", () => { expect(parseSearchScope("music")).toBe("music"); expect(parseSearchScope("tv")).toBe("tv"); }); it("falls back on absent or unrecognised values", () => { expect(parseSearchScope(null)).toBe("all"); expect(parseSearchScope("")).toBe("all"); expect(parseSearchScope("books")).toBe("all"); expect(parseSearchScope(null, "music")).toBe("music"); }); }); describe("seedFromSearchUrl", () => { const params = (search: string) => new URL(`http://x/search${search}`).searchParams; it("seeds a fresh page from the URL", () => { expect(seedFromSearchUrl(params("?q=jazz&scope=music"), null)).toEqual({ query: "jazz", scope: "music", }); }); it("seeds an empty query so an emptied URL clears the page", () => { expect(seedFromSearchUrl(params(""), null)).toEqual({ query: "", scope: "all" }); expect(seedFromSearchUrl(params(""), { query: "jazz", scope: "all" })).toEqual({ query: "", scope: "all", }); }); it("asks for nothing once that same URL has been applied", () => { // The regression this exists for: the page must consume the URL once, not // keep re-asserting it. While the seed is unchanged the user's typing and // chip picks own the input — re-applying snapped it back a keystroke later. const applied = { query: "jazz", scope: "music" } as const; expect(seedFromSearchUrl(params("?q=jazz&scope=music"), applied)).toBeNull(); }); it("re-seeds when the query or the scope actually changes", () => { const applied = { query: "jazz", scope: "music" } as const; expect(seedFromSearchUrl(params("?q=blues&scope=music"), applied)).toEqual({ query: "blues", scope: "music", }); expect(seedFromSearchUrl(params("?q=jazz"), applied)).toEqual({ query: "jazz", scope: "all", }); }); });