search.integration.test.ts

search.integration.test.tstests/integration/search.integration.test.tsraw ← integration12,577 B← Back to the app
1/**
2 * AI Software Factory — Integration: Search (TASK-0097 S3)
3 *
4 * The search API (POST /search, GET /search/query, /search/suggest, and the
5 * recent-search routes) against the REAL API + a REAL OpenSearch. It exercises
6 * the full HTTP contract: the global auth guard, the Zod validation pipe, the
7 * fail-closed caller-scope resolver, the tenant clause, and the 400/404/503
8 * error mapping (docs/api/search.md).
9 *
10 * ── RUNNER GATE (Docker + OpenSearch) — SELF-SKIPS WHEN THE STACK IS ABSENT ──
11 * The suite needs TWO things:
12 *   1. A Docker daemon (Testcontainers Postgres/Redis via createTestApp — the
13 *      same infra the other integration specs use), AND
14 *   2. A reachable OpenSearch at the API's SEARCH_URL (default
15 *      http://localhost:9200) — the full dev/CI stack's search engine, NOT a
16 *      container this spec controls. The `factory-content` index is the
17 *      stack's SHARED index and the search-indexer worker is the only thing
18 *      that writes it in production, so THIS spec seeds it directly with
19 *      `@factory/search`'s `SearchClient` (no worker builder imports).
20 * When either is absent (e.g. a Docker-less authoring host) the whole suite
21 * SKIPs — an honest skip, not a fake pass. CI (the full stack up, OpenSearch
22 * waited-for at :9200, `SEARCH_URL` set to it) runs it green. The gate is
23 * evaluated at COLLECTION time (a sync Docker probe + one async OpenSearch
24 * health probe, via a top-level `await` — the file is ESM) and feeds
25 * `describe.skipIf`, so an absent stack never fails the suite.
26 *
27 * Covered:
28 *   - the caller's OWN workspace doc comes back in `data` (docId/type/title),
29 *   - tenant isolation: another workspace's doc NEVER appears for the caller,
30 *     and an explicit `workspaceId` the caller is not a member of → 404,
31 *   - validation: `limit` 51 → 400 VALIDATION_ERROR, `limit` 50 → 200.
32 *
33 * NOTE (recorded, TASK-0097 S3): the other root integration specs import the
34 * shared helpers via `../helpers/*`, which resolves OUTSIDE the package
35 * (`tests/helpers/` does not exist — the helpers live at
36 * `tests/integration/helpers/`), so those specs currently fail to LOAD under
37 * vitest (pre-existing, repo-wide; see the S3 report). This spec imports
38 * them via `./helpers/*` — the path that resolves — so it is independently
39 * CI-ready. If the suite-wide import/layout fix lands, adjust to match.
40 */
41import { afterAll, beforeAll, describe, expect, it } from "vitest";
42import { execSync } from "node:child_process";
43import { SearchClient, contentMapping, type SearchDoc } from "@factory/search";
44import { createTestApp, type TestAppHandle } from "./helpers/api";
45import { authHeaders, createWorkspace, createUser } from "./helpers/seed";
46 
47/** The OpenSearch the API talks to (API's SEARCH_URL default). */
48const SEARCH_URL = process.env.SEARCH_URL ?? "http://localhost:9200";
49 
50/** Docker present? (sync probe — Testcontainers Postgres/Redis need it). */
51function dockerAvailable(): boolean {
52  try {
53    execSync("docker info", { stdio: "ignore", timeout: 8_000 });
54    return true;
55  } catch {
56    return false;
57  }
58}
59 
60/** Is the OpenSearch at `url` (the API's SEARCH_URL) reachable? */
61async function opensearchUp(url: string): Promise<boolean> {
62  try {
63    const res = await fetch(`${url.replace(/\/+$/, "")}/_cluster/health`, {
64      signal: AbortSignal.timeout(5_000),
65    });
66    return res.ok;
67  } catch {
68    return false;
69  }
70}
71 
72/**
73 * Collection-time stack gate (Docker + OpenSearch). A top-level `await` is
74 * safe here — the file is ESM and Vitest awaits the module before collecting
75 * its tests — so `describe.skipIf` below sees a settled boolean.
76 */
77const stackReady = dockerAvailable() && (await opensearchUp(SEARCH_URL));
78 
79/** Run-unique suffix — the shared `factory-content` index persists across
80 *  dev-stack runs, so doc ids must not collide between runs. */
81const RUN = Date.now().toString(36);
82 
83const json = async (res: Response): Promise<Record<string, unknown>> =>
84  (await res.json().catch(() => ({}))) as Record<string, unknown>;
85 
86/** Hand-built content doc (the same shape the worker's builder emits). */
87function makeDoc(
88  over: Partial<SearchDoc> & Pick<SearchDoc, "docId" | "type" | "id" | "title" | "workspaceId">,
89): SearchDoc {
90  return {
91    body: "quarterly forecast and budget review",
92    grants: { public: false, workspace: true, user: false, teams: [], users: [] },
93    archived: false,
94    url: `/w/${over.workspaceId}/p/${over.id}`,
95    createdAt: "2025-01-01T00:00:00.000Z",
96    updatedAt: "2025-06-01T00:00:00.000Z",
97    ...over,
98  };
99}
100 
101let app: TestAppHandle;
102let client: SearchClient;
103let ws1 = ""; // user A's workspace
104let ws2 = ""; // user B's workspace
105let docA = ""; // docId of user A's indexed page
106let docB = ""; // docId of user B's indexed page
107let authA: Record<string, string> = {}; // bearer header for user A (the ws1 owner)
108 
109describe.skipIf(!stackReady)(
110  "Search integration (TASK-0097 S3)",
111  () => {
112    beforeAll(async () => {
113      app = await createTestApp();
114      client = new SearchClient({ baseUrl: SEARCH_URL });
115      // Ensure the single content index the API reads from exists with the
116      // canonical mapping (keyword workspaceId/type/grants, text title/body).
117      // CI pre-creates only `factory-docs`, so this is what makes the
118      // `factory-content` target present (idempotent).
119      const mapping = contentMapping() as {
120        settings: Record<string, unknown>;
121        mappings: Record<string, unknown>;
122      };
123      // TASK-0125: `factory-content` may be an ALIAS (the dev stack + the
124      // reindex rollover point it at `factory-content-vN`), so a bare
125      // `PUT /factory-content` 400s (alias vs index). Create only when the
126      // name is genuinely absent — `indexExists` resolves through aliases, so
127      // this is idempotent for both the real-index and the alias cases (a
128      // fresh CI stack still gets the plain index).
129      if (!(await client.indexExists("factory-content"))) {
130        await client.createIndexIfMissing("factory-content", mapping);
131      }
132 
133      // Fixtures THROUGH THE API (real authorization layer): two users, each
134      // owner of their own workspace (tenant isolation needs two tenants).
135      const userA = await createUser(app.request, { name: "Search Owner A" });
136      ws1 = (await createWorkspace(app.request, authHeaders(userA.accessToken!), "Search WS A"))
137        .workspaceId;
138      authA = authHeaders(userA.accessToken!);
139      const userB = await createUser(app.request, { name: "Search Owner B" });
140      ws2 = (await createWorkspace(app.request, authHeaders(userB.accessToken!), "Search WS B"))
141        .workspaceId;
142 
143      // Hand-build + index one page per workspace into the SHARED index
144      // (packages/search is the ONLY search dep here — no worker builder
145      // imports), then refresh so they are immediately queryable.
146      docA = `page:${RUN}-a1`;
147      docB = `page:${RUN}-b1`;
148      await client.indexDocs([
149        makeDoc({
150          docId: docA,
151          type: "page",
152          id: `${RUN}-a1`,
153          title: "Q3 Forecast",
154          workspaceId: ws1,
155        }),
156        makeDoc({
157          docId: docB,
158          type: "page",
159          id: `${RUN}-b1`,
160          title: "Q3 Forecast",
161          workspaceId: ws2,
162        }),
163      ]);
164      await client.refresh();
165    }, 180_000);
166    afterAll(async () => {
167      await app?.close();
168    });
169 
170    it("POST /search returns the caller's own workspace doc (docId/type/title)", async () => {
171      const h = authA;
172      const res = await app.request("POST", "/api/v1/search", {
173        headers: h,
174        body: { q: "forecast" },
175      });
176      expect(res.status).toBe(200);
177      const body = await json(res);
178      expect(typeof body.tookMs).toBe("number");
179      expect("nextCursor" in body).toBe(true);
180      const data = (body.data as Array<Record<string, unknown>>) ?? [];
181      const mine = data.find((d) => d.docId === docA);
182      expect(mine, "the caller's own workspace doc must be in data").toBeTruthy();
183      expect(mine).toMatchObject({
184        docId: docA,
185        type: "page",
186        title: "Q3 Forecast",
187        workspaceId: ws1,
188      });
189    });
190 
191    it("tenant isolation: another workspace's doc never appears for the caller", async () => {
192      const h = authA;
193      const res = await app.request("POST", "/api/v1/search", {
194        headers: h,
195        body: { q: "forecast" },
196      });
197      expect(res.status).toBe(200);
198      const data = ((await json(res)).data as Array<Record<string, unknown>>) ?? [];
199      const foreign = data.find((d) => d.docId === docB || d.workspaceId === ws2);
200      expect(
201        foreign,
202        "a doc from a workspace the caller is not a member of must NOT appear",
203      ).toBeUndefined();
204    });
205 
206    it("explicit workspaceId the caller is NOT a member of → 404 NOT_FOUND (no leak)", async () => {
207      const h = authA;
208      const res = await app.request("POST", "/api/v1/search", {
209        headers: h,
210        body: { q: "forecast", workspaceId: ws2 },
211      });
212      expect(res.status).toBe(404);
213      const body = await json(res);
214      expect((body.error as { code?: string })?.code).toBe("NOT_FOUND");
215    });
216 
217    it("validation: limit 51 → 400 VALIDATION_ERROR, limit 50 → 200", async () => {
218      const h = authA;
219      const bad = await app.request("POST", "/api/v1/search", {
220        headers: h,
221        body: { q: "forecast", limit: 51 },
222      });
223      expect(bad.status).toBe(400);
224      expect(((await json(bad)).error as { code?: string })?.code).toBe("VALIDATION_ERROR");
225 
226      const ok = await app.request("POST", "/api/v1/search", {
227        headers: h,
228        body: { q: "forecast", limit: 50 },
229      });
230      expect(ok.status).toBe(200);
231    });
232 
233    it("T-155 sortBy=createdAt orders newest-first (deterministic, direct index)", async () => {
234      const h = authA;
235      // Three docs in ws1 sharing a unique title token, with DISTINCT
236      // createdAt — a query for the token matches all three, so the ordering
237      // is what is under test. (updatedAt is identical for all → the
238      // updatedAt branch is only asserted for 200 + count, not exact order.)
239      // A single, spaceless, run-unique token — no pre-existing doc can match
240      // it, so a query for it matches exactly these three.
241      const token = `sortfix${RUN}x`;
242      const createdAt = [
243        "2025-01-15T00:00:00.000Z",
244        "2025-03-15T00:00:00.000Z",
245        "2025-05-15T00:00:00.000Z",
246      ];
247      const ids = [`${RUN}-s1`, `${RUN}-s2`, `${RUN}-s3`];
248      await client.indexDocs(
249        createdAt.map((d, i) =>
250          makeDoc({
251            docId: `page:${ids[i]}`,
252            type: "page",
253            id: ids[i]!,
254            title: token,
255            workspaceId: ws1,
256            createdAt: d,
257          }),
258        ),
259      );
260      await client.refresh();
261 
262      // sortBy=createdAt → newest first (s3, s2, s1).
263      const sorted = await app.request("POST", "/api/v1/search", {
264        headers: h,
265        body: { q: token, workspaceId: ws1, sortBy: "createdAt", limit: 50 },
266      });
267      expect(sorted.status).toBe(200);
268      const sdata = ((await json(sorted)).data as Array<Record<string, unknown>>) ?? [];
269      expect(sdata.map((d) => d.id)).toEqual([ids[2], ids[1], ids[0]]);
270 
271      // sortBy=updatedAt → 200 + all three (order not asserted: identical updatedAt).
272      const upd = await app.request("POST", "/api/v1/search", {
273        headers: h,
274        body: { q: token, workspaceId: ws1, sortBy: "updatedAt", limit: 50 },
275      });
276      expect(upd.status).toBe(200);
277      expect(((await json(upd)).data as unknown[]).length).toBe(3);
278 
279      // Relevance (default) is unchanged: the same three docs, any order.
280      const rel = await app.request("POST", "/api/v1/search", {
281        headers: h,
282        body: { q: token, workspaceId: ws1, limit: 50 },
283      });
284      expect(rel.status).toBe(200);
285      const rids = ((await json(rel)).data as Array<Record<string, unknown>>)
286        .map((d) => d.id as string)
287        .sort();
288      expect(rids).toEqual([...ids].sort());
289    });
290 
291    it("T-155 invalid sortBy → 400 VALIDATION_ERROR", async () => {
292      const h = authA;
293      const bad = await app.request("POST", "/api/v1/search", {
294        headers: h,
295        body: { q: "forecast", sortBy: "not-a-sort" },
296      });
297      expect(bad.status).toBe(400);
298      expect(((await json(bad)).error as { code?: string })?.code).toBe("VALIDATION_ERROR");
299    });
300  },
301  180_000,
302);
303