@salesforce/ui-bundle-template-feature-angular-search 0.0.0-stage → 12.14.0

package/dist/force-app/main/default/uiBundles/feature-angular-search/src/app/features/search/state/search-state.service.spec.ts

@@ -0,0 +1,293 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { TestBed } from "@angular/core/testing";
+import { ActivatedRoute, convertToParamMap, Router } from "@angular/router";
+import { BehaviorSubject } from "rxjs";
+import { describe, expect, it, vi } from "vitest";
+import { SearchService } from "../api/search.service";
+import type { SearchConfig } from "../types/search-config.types";
+import type { RunSearchOutcome, SourceRequest } from "../types/search-result.types";
+import { SearchStateService } from "./search-state.service";
+
+const config = (mode: "per-source" | "merged"): SearchConfig => ({
+	pagination: { mode, pageSize: 2, pageSizeOptions: [2, 4] },
+	sources: [
+		{
+			kind: "sobject",
+			key: "a",
+			objectName: "Account",
+			label: "Accounts",
+			searchableFields: ["Name"],
+			displayFields: ["Name"],
+		},
+		{
+			kind: "sobject",
+			key: "c",
+			objectName: "Contact",
+			label: "Contacts",
+			searchableFields: ["Name"],
+			displayFields: ["Name"],
+		},
+	],
+});
+
+function setup(cfg: SearchConfig, queryParams: Record<string, string> = {}) {
+	const runSearch = vi.fn(async (requests: SourceRequest[]): Promise<RunSearchOutcome> => ({
+		results: Object.fromEntries(
+			requests.map((r) => [
+				r.source.key,
+				{
+					nodes: [{ Id: `${r.source.key}1` }, { Id: `${r.source.key}2` }],
+					pageInfo: {
+						hasNextPage: true,
+						hasPreviousPage: false,
+						startCursor: null,
+						endCursor: `${r.source.key}-end`,
+					},
+					totalCount: 10,
+				},
+			]),
+		),
+		errors: {},
+	}));
+	const navigate = vi.fn(async () => true);
+	const queryParamMap = new BehaviorSubject(convertToParamMap(queryParams));
+	TestBed.configureTestingModule({
+		providers: [
+			SearchStateService,
+			{ provide: SearchService, useValue: { runSearch, fetchDistinctValues: vi.fn() } },
+			{ provide: Router, useValue: { navigate } },
+			{ provide: ActivatedRoute, useValue: { snapshot: { queryParams }, queryParamMap } },
+		],
+	});
+	const state = TestBed.inject(SearchStateService);
+	state.init(cfg);
+	return { state, runSearch, navigate, queryParamMap };
+}
+
+async function settle(): Promise<void> {
+	for (let i = 0; i < 4; i++) {
+		TestBed.tick();
+		await Promise.resolve();
+		await new Promise((r) => setTimeout(r, 0));
+	}
+}
+
+describe("SearchStateService", () => {
+	it("does not fetch while the term is shorter than the minimum length", async () => {
+		const { state, runSearch } = setup(config("per-source"));
+		state.setQ("ab");
+		await settle();
+		expect(runSearch).not.toHaveBeenCalled();
+		expect(state.loading()).toBe(false);
+	});
+
+	it("fetches every in-scope source in one request", async () => {
+		const { state, runSearch } = setup(config("per-source"));
+		state.setQ("acme");
+		await settle();
+		expect(runSearch).toHaveBeenCalledTimes(1);
+		expect(runSearch.mock.calls[0]?.[0].map((r) => r.source.key)).toEqual(["a", "c"]);
+		expect(state.totalCount()).toBe(20);
+	});
+
+	it("narrows the request to the selected scope", async () => {
+		const { state, runSearch } = setup(config("per-source"));
+		state.setQ("acme");
+		await settle();
+		state.setScope("c");
+		await settle();
+		expect(runSearch.mock.calls.at(-1)?.[0].map((r) => r.source.key)).toEqual(["c"]);
+	});
+
+	it("advances and rewinds a source page with a cursor stack", async () => {
+		const { state, runSearch } = setup(config("per-source"));
+		state.setQ("acme");
+		await settle();
+		state.goToNextSourcePage("a");
+		await settle();
+		const next = runSearch.mock.calls.at(-1)?.[0].find((r) => r.source.key === "a");
+		expect(next?.afterCursor).toBe("a-end");
+		expect(state.sources()["a"]?.pageIndex).toBe(1);
+		state.goToPreviousSourcePage("a");
+		await settle();
+		const prev = runSearch.mock.calls.at(-1)?.[0].find((r) => r.source.key === "a");
+		expect(prev?.afterCursor).toBeUndefined();
+		expect(state.sources()["a"]?.pageIndex).toBe(0);
+	});
+
+	it("uses a front-anchored window with no cursor in merged mode", async () => {
+		const { state, runSearch } = setup(config("merged"));
+		state.setQ("acme");
+		await settle();
+		state.goToNextPage();
+		await settle();
+		const reqs = runSearch.mock.calls.at(-1)?.[0] ?? [];
+		expect(reqs.every((r) => r.pageSize === 4 && r.afterCursor === undefined)).toBe(true);
+		expect(state.globalPagination().pageIndex).toBe(1);
+	});
+
+	it("seeds the term and page cursor from the URL", () => {
+		const { state } = setup(config("per-source"), {
+			q: "acme",
+			"s.a.page": "3",
+			"s.a.after": "cur",
+		});
+		expect(state.q()).toBe("acme");
+		expect(state.sources()["a"]?.pageIndex).toBe(2);
+	});
+
+	it("writes the term to the URL after the debounce and never writes the scope", async () => {
+		const { state, navigate } = setup(config("per-source"));
+		state.setQ("acme");
+		state.setScope("c");
+		await new Promise((r) => setTimeout(r, 400));
+		expect(navigate).toHaveBeenCalled();
+		const call = navigate.mock.calls.at(-1) as unknown as [
+			unknown,
+			{ queryParams: Record<string, unknown> },
+		];
+		expect(call[1].queryParams["q"]).toBe("acme");
+		expect(JSON.stringify(call[1].queryParams)).not.toContain("scope");
+	});
+
+	it("restores the merged page from the URL", async () => {
+		const { state, runSearch } = setup(config("merged"), { q: "acme", page: "2" });
+		await settle();
+		expect(runSearch.mock.calls[0]?.[0][0]?.pageSize).toBe(4);
+		expect(state.globalPagination().pageIndex).toBe(1);
+	});
+
+	it("clamps a restored merged page to the last page once totals are known", async () => {
+		const clamped = setup(config("merged"), { q: "acme", page: "99" });
+		await settle();
+		// 20 total at page size 2 -> last page index 9
+		expect(clamped.state.globalPagination().pageIndex).toBe(9);
+		expect(clamped.runSearch.mock.calls.at(-1)?.[0][0]?.pageSize).toBe(20);
+	});
+
+	it("writes the merged page to the URL", async () => {
+		const { state, navigate } = setup(config("merged"));
+		state.setQ("acme");
+		await settle();
+		state.goToNextPage();
+		await new Promise((r) => setTimeout(r, 400));
+		const call = navigate.mock.calls.at(-1) as unknown as [
+			unknown,
+			{ queryParams: Record<string, unknown> },
+		];
+		expect(call[1].queryParams["page"]).toBe("2");
+	});
+
+	it("survives a crafted huge page number and Previous falls back to page one", async () => {
+		const { state, runSearch } = setup(config("per-source"), {
+			q: "acme",
+			"s.a.page": "99999999999",
+			"s.a.after": "x",
+		});
+		await settle();
+		expect(state.sources()["a"]?.pageIndex).toBeLessThanOrEqual(1000);
+		state.goToPreviousSourcePage("a");
+		await settle();
+		expect(state.sources()["a"]?.pageIndex).toBe(0);
+		const req = runSearch.mock.calls.at(-1)?.[0].find((r) => r.source.key === "a");
+		expect(req?.afterCursor).toBeUndefined();
+	});
+
+	it("Previous after a restore and one Next returns to the restored page", async () => {
+		const { state, runSearch } = setup(config("per-source"), {
+			q: "acme",
+			"s.a.page": "3",
+			"s.a.after": "C3",
+		});
+		await settle();
+		state.goToNextSourcePage("a");
+		await settle();
+		state.goToPreviousSourcePage("a");
+		await settle();
+		const req = runSearch.mock.calls.at(-1)?.[0].find((r) => r.source.key === "a");
+		expect(req?.afterCursor).toBe("C3");
+		expect(state.sources()["a"]?.pageIndex).toBe(2);
+	});
+
+	it("follows an external q change without echoing its own writes", async () => {
+		const { state, queryParamMap } = setup(config("per-source"), { q: "acme" });
+		queryParamMap.next(convertToParamMap({ q: "globex" }));
+		expect(state.q()).toBe("globex");
+		state.setQ("initech");
+		await new Promise((r) => setTimeout(r, 400));
+		queryParamMap.next(convertToParamMap({ q: "initech" }));
+		expect(state.q()).toBe("initech");
+	});
+
+	it("guards goToPage against NaN and out-of-range pages in merged mode", async () => {
+		const { state } = setup(config("merged"), { q: "acme" });
+		await settle();
+		state.goToPage(Number.NaN);
+		expect(state.globalPagination().pageIndex).toBe(0);
+		state.goToPage(500);
+		await settle();
+		expect(state.globalPagination().pageIndex).toBe(9);
+	});
+
+	it("restores and writes the merged page size, and merges query params", async () => {
+		const { state, navigate } = setup(config("merged"), { q: "acme", size: "4" });
+		expect(state.globalPagination().pageSize).toBe(4);
+		state.setPageSize(2);
+		await new Promise((r) => setTimeout(r, 400));
+		const call = navigate.mock.calls.at(-1) as unknown as [
+			unknown,
+			{ queryParams: Record<string, unknown>; queryParamsHandling: string },
+		];
+		expect(call[1].queryParamsHandling).toBe("merge");
+		expect(call[1].queryParams["size"]).toBeNull();
+	});
+
+	it("applies setPageSize to every source in per-source mode", () => {
+		const { state } = setup(config("per-source"));
+		state.setScope("a");
+		state.setPageSize(4);
+		state.setScope("all");
+		expect(state.sources()["c"]?.pageSize).toBe(4);
+	});
+
+	it("retries distinct values after a failure", async () => {
+		const { state } = setup(config("per-source"));
+		const svc = TestBed.inject(SearchService) as unknown as {
+			fetchDistinctValues: ReturnType<typeof vi.fn>;
+		};
+		svc.fetchDistinctValues
+			.mockRejectedValueOnce(new Error("boom"))
+			.mockResolvedValueOnce([{ value: "x", label: "x" }]);
+		vi.spyOn(console, "error").mockImplementation(() => undefined);
+		state.distinctOptions("Account", "Industry");
+		await settle();
+		expect(state.distinctOptions("Account", "Industry")()).toEqual([]);
+		await settle();
+		expect(state.distinctOptions("Account", "Industry")()).toEqual([{ value: "x", label: "x" }]);
+	});
+
+	it("reports an invalid config through configError and error, and does not fetch", async () => {
+		const bad = { ...config("per-source"), sources: [] };
+		const { state, runSearch } = setup(bad);
+		state.setQ("acme");
+		await settle();
+		expect(state.configError()).toContain("at least one source");
+		expect(state.error()).toBe(state.configError());
+		expect(runSearch).not.toHaveBeenCalled();
+	});
+
+	it("drops an unknown URL sort field and falls back to the default sort", () => {
+		const cfg = config("per-source");
+		cfg.sources[0] = {
+			...cfg.sources[0]!,
+			sortBy: [{ field: "Name", label: "Name" }],
+			defaultSort: { field: "Name", direction: "ASC" },
+		};
+		const { state } = setup(cfg, { "s.a.sort": "Bogus", "s.a.dir": "DESC" });
+		expect(state.sources()["a"]?.sort).toEqual({ field: "Name", direction: "ASC" });
+	});
+});