Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/search.api.test.tsx
T

211 lines
8.3 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const serviceMocks = vi.hoisted(() => {
class MockGlobalSearchInputError extends Error {
readonly code: string;
constructor(code: string) {
super(code);
this.code = code;
}
}
class MockGlobalSearchUnavailableError extends Error {}
return {
MockGlobalSearchInputError,
MockGlobalSearchUnavailableError,
loadSearchContext: vi.fn(),
recordCommittedSearch: vi.fn(),
runGlobalSearch: vi.fn(),
};
});
const csrfMocks = vi.hoisted(() => ({ validate: vi.fn() }));
vi.mock("~/services/search/globalSearch.server", () => ({
GlobalSearchInputError: serviceMocks.MockGlobalSearchInputError,
GlobalSearchUnavailableError: serviceMocks.MockGlobalSearchUnavailableError,
loadSearchContext: serviceMocks.loadSearchContext,
recordCommittedSearch: serviceMocks.recordCommittedSearch,
runGlobalSearch: serviceMocks.runGlobalSearch,
}));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: csrfMocks.validate }));
import { action, loader } from "./search.api";
const ctx = {
tenantId: "tenant_1",
tenantSlug: "acme",
userId: "user_1",
permissions: ["search.use"],
};
describe("search resource route", () => {
beforeEach(() => {
vi.clearAllMocks();
serviceMocks.loadSearchContext.mockResolvedValue(ctx);
serviceMocks.runGlobalSearch.mockResolvedValue({
query: "Ada",
requestedEntityTypes: ["contact"],
requestId: "request-7",
requestKey: "Ada|contact|8",
results: [],
recentSearches: [],
hiddenEntityTypes: [],
latencyHint: "Search index updates can take up to 10 seconds.",
});
serviceMocks.recordCommittedSearch.mockResolvedValue({ recorded: true, requestKey: "Ada|contact,project|*" });
csrfMocks.validate.mockResolvedValue(undefined);
});
it("keeps GET read-only and forwards query, filter, limit, and request identity", async () => {
const request = new Request("https://app.example.test/acme/search/api?q=Ada&type=contact&limit=8&requestId=request-7");
const response = await loader({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(200);
expect(serviceMocks.runGlobalSearch).toHaveBeenCalledWith({
request,
params: { tenant: "acme" },
query: "Ada",
limit: 8,
entityTypes: ["contact"],
requestId: "request-7",
});
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
await expect(response.json()).resolves.toMatchObject({ latencyHint: "Search index updates can take up to 10 seconds." });
});
it("maps invalid GET input to a bounded 400 response", async () => {
serviceMocks.runGlobalSearch.mockRejectedValueOnce(new serviceMocks.MockGlobalSearchInputError("query_too_long"));
const request = new Request("https://app.example.test/acme/search/api?q=too-long");
const response = await loader({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ error: "query_too_long" });
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("returns a bounded service error that the Spotlight controller can render", async () => {
serviceMocks.runGlobalSearch.mockRejectedValueOnce(new serviceMocks.MockGlobalSearchUnavailableError("database unavailable"));
const request = new Request("https://app.example.test/acme/search/api?q=Ada");
const response = await loader({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(503);
await expect(response.json()).resolves.toEqual({ error: "search_unavailable" });
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("records only an explicit committed result with the authenticated context", async () => {
const form = new URLSearchParams({
intent: "recordRecent",
query: "Ada",
resultCount: "7",
selectedEntityType: "contact",
selectedEntityId: "kontakt_1",
csrf: "csrf-token",
});
form.append("type", "contact");
form.append("type", "project");
const request = new Request("https://app.example.test/acme/search/api", { method: "POST", body: form });
const response = await action({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual({ ok: true, recorded: true, requestKey: "Ada|contact,project|*" });
expect(serviceMocks.loadSearchContext).toHaveBeenCalledWith({ request, params: { tenant: "acme" } });
expect(csrfMocks.validate).toHaveBeenCalledWith(request, { formData: expect.anything() });
expect(serviceMocks.recordCommittedSearch).toHaveBeenCalledWith({
ctx,
query: "Ada",
entityTypes: ["contact", "project"],
resultCount: "7",
selectedEntityType: "contact",
selectedEntityId: "kontakt_1",
});
});
it("returns success with recorded=false when history persistence fails safely", async () => {
serviceMocks.recordCommittedSearch.mockResolvedValueOnce({ recorded: false, requestKey: "Ada|contact|*" });
const request = createCommitRequest();
const response = await action({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual({ ok: true, recorded: false, requestKey: "Ada|contact|*" });
});
it("rejects unsupported content types before parsing or CSRF validation", async () => {
const request = new Request("https://app.example.test/acme/search/api", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ intent: "recordRecent" }),
});
const response = await action({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(415);
await expect(response.json()).resolves.toEqual({ error: "unsupported_media_type" });
expect(csrfMocks.validate).not.toHaveBeenCalled();
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("rejects unknown intents after CSRF validation and before persistence", async () => {
const request = new Request("https://app.example.test/acme/search/api", {
method: "POST",
body: new URLSearchParams({ intent: "unknown", csrf: "csrf-token" }),
});
const response = await action({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ error: "invalid_intent" });
expect(csrfMocks.validate).toHaveBeenCalledWith(request, { formData: expect.anything() });
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("enforces search access before CSRF validation and persistence", async () => {
serviceMocks.loadSearchContext.mockRejectedValueOnce(new Error("permission denied"));
const request = createCommitRequest();
await expect(action({ request, params: { tenant: "acme" }, context: {} })).rejects.toThrow("permission denied");
expect(csrfMocks.validate).not.toHaveBeenCalled();
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("stops before persistence when CSRF validation fails", async () => {
csrfMocks.validate.mockRejectedValueOnce(new Error("invalid csrf"));
const request = createCommitRequest();
await expect(action({ request, params: { tenant: "acme" }, context: {} })).rejects.toThrow("invalid csrf");
expect(serviceMocks.recordCommittedSearch).not.toHaveBeenCalled();
});
it("maps invalid search input to a bounded 400 response", async () => {
serviceMocks.recordCommittedSearch.mockRejectedValueOnce(new serviceMocks.MockGlobalSearchInputError("invalid_result_count"));
const request = createCommitRequest();
const response = await action({ request, params: { tenant: "acme" }, context: {} });
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ error: "invalid_result_count" });
});
});
function createCommitRequest() {
return new Request("https://app.example.test/acme/search/api", {
method: "POST",
body: new URLSearchParams({
intent: "recordRecent",
query: "Ada",
resultCount: "1",
type: "contact",
selectedEntityType: "contact",
selectedEntityId: "kontakt_1",
csrf: "csrf-token",
}),
});
}