Files
0pt/tests/p0/search-service.test.ts
T
admin 3edc56dcdb
Security Scan (SIAX Cloud) / security (push) Successful in 16s
CI (SIAX Cloud) / security (push) Successful in 17s
CI (SIAX Cloud) / integration (push) Successful in 29s
CI (SIAX Cloud) / quality (push) Successful in 48s
Security Scan (SIAX Cloud) / security (pull_request) Successful in 15s
CI (SIAX Cloud) / security (pull_request) Successful in 28s
CI (SIAX Cloud) / quality (pull_request) Successful in 48s
CI (SIAX Cloud) / integration (pull_request) Successful in 55s
Python Engine CI (SIAX Cloud) / python-engine (push) Failing after 4m52s
Python Engine CI (SIAX Cloud) / python-engine (pull_request) Failing after 4m48s
fix: slutgranskning av dataset/search/ER-ytorna + STATUS-sanning
Slutgate inför merge (per fortsättningsplan):

Kontrakt: CreateDatasetVersionInput.artifact_refs → readonly string[]
(anropare får skicka 'as const'; servicen muterar aldrig); postgres.js
tx.array() får muterbar kopia vid INSERT.

Testkorrigeringar (stale mot starkare implementation — aldrig svagare):
- entity-resolution-http: request(body, undefined) triggade default-param
  och skickade GILTIGT token → 200. Tomt token = 'utan token' → 401 fail-closed.
- entity-resolution: /two records/ → /between 2 and 5000/ (bounds-aware validering)
- search-service: omformat purpose-filter-test + NY negativ kontroll —
  rebuild avvisar dokument utan purpose_tags (fail closed, generation discarded)
- dataset-postgres.realinfra: sätter DATABASE_URL i setup så den durabla
  AUD0-outboxen aktiveras (testet ljög annars om durabilitet) — 5/5 mot live Postgres

STATUS.md: AUD0-klient + lineage-rader (outbox nu real-infra testad),
gap-listan (persistence/routes/outbox stängda, exakt vad som återstår),
P065 STÄNGD med closure-record (thin adapter, v3-semantik, hard-negative
transitivitet, fail-closed 401 — 4/4 planpunkter verifierade).

Verifierat: typecheck EXIT 0 · 945/945 unit · 5/5 real-Postgres · next build EXIT 0
2026-09-07 19:31:22 +02:00

266 lines
11 KiB
TypeScript

/**
* SearchService unit tests (Master-DoD §10 Search) against a faithful
* in-memory OpenSearchAdapter fake (indices, aliases, bool-query subset).
* The REAL adapter is exercised by
* tests/integration/search-opensearch.integration.test.ts against a live
* OpenSearch container — this file tests the 0pt semantics: tenant +
* purpose/rights enforcement, generation switch, rebuild isolation.
*/
import { describe, it, expect } from "vitest";
import { SearchService, type DocumentSource } from "@/src/search/search-service";
import type { OpenSearchAdapter, OpenSearchSearchBody } from "@/src/search/opensearch-adapter";
import type { SearchDocument } from "@/src/search/search-types";
import { SiaxError } from "@/src/platform/errors";
// ---------------------------------------------------------------------------
// In-memory OpenSearch fake — supports the exact query shape SearchService builds.
// ---------------------------------------------------------------------------
class FakeOpenSearch implements OpenSearchAdapter {
indices = new Map<string, Map<string, Record<string, unknown>>>();
aliases = new Map<string, string>();
async createIndex(physicalIndex: string): Promise<void> {
if (this.indices.has(physicalIndex)) throw new SiaxError("CONFLICT", "opensearch", "exists");
this.indices.set(physicalIndex, new Map());
}
async deleteIndex(physicalIndex: string): Promise<void> {
this.indices.delete(physicalIndex);
}
async indexExists(physicalIndex: string): Promise<boolean> {
return this.indices.has(physicalIndex);
}
async bulkIndex(physicalIndex: string, docs: { id: string; body: Record<string, unknown> }[]) {
const idx = this.indices.get(physicalIndex);
if (!idx) return { errors: docs.map((d) => ({ doc_id: d.id, error: "index_not_found" })) };
for (const d of docs) idx.set(d.id, d.body);
return { errors: [] };
}
async search(target: string, body: OpenSearchSearchBody) {
const physical = this.aliases.get(target) ?? target;
const idx = this.indices.get(physical);
if (!idx) return { total: 0, hits: [] };
const bool = (body.query as { bool: { must: unknown[]; filter: { term: Record<string, unknown> }[] } }).bool;
const rows = [...idx.entries()].filter(([, src]) => {
for (const f of bool.filter) {
const [field, value] = Object.entries(f.term)[0];
const actual = src[field];
if (Array.isArray(actual) ? !actual.includes(value) : actual !== value) return false;
}
const mm = (bool.must[0] as { multi_match?: { query: string; fields: string[] } }).multi_match;
if (mm) {
const q = mm.query.toLowerCase();
if (!mm.fields.some((f) => String(src[f] ?? "").toLowerCase().includes(q))) return false;
}
return true;
});
const from = body.from ?? 0;
const size = body.size ?? 10;
return {
total: rows.length,
hits: rows.slice(from, from + size).map(([id, src]) => ({
_id: id,
_score: 1,
_index: physical,
_source: src,
})),
};
}
async switchAlias(alias: string, physicalIndex: string): Promise<void> {
this.aliases.set(alias, physicalIndex);
}
async aliasTargets(alias: string): Promise<string[]> {
const t = this.aliases.get(alias);
return t ? [t] : [];
}
async listIndices(pattern: string): Promise<string[]> {
const re = new RegExp(`^${pattern.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, ".*")}$`);
return [...this.indices.keys()].filter((i) => re.test(i));
}
async refresh(): Promise<void> {}
async health(): Promise<{ status: string }> {
return { status: "green" };
}
}
const DEF = {
index_name: "companies",
version: 1,
fields: { name: "text", org_nr: "keyword", employees: "long" } as const,
default_search_fields: ["name"],
};
function docsSource(docs: SearchDocument[]): DocumentSource {
return {
name: "test:canonical",
async *iterate() {
yield* docs;
},
};
}
function doc(id: string, tenant: string, name: string, extra: Partial<SearchDocument> = {}): SearchDocument {
return {
doc_id: id,
tenant_id: tenant,
purpose_tags: ["company_enrichment"],
rights_tags: ["internal"],
payload: { name, org_nr: `55${id}`, employees: 10 },
...extra,
};
}
async function build(docs: SearchDocument[]) {
const fake = new FakeOpenSearch();
const search = new SearchService(fake);
search.registerIndexDefinition({ ...DEF, fields: { ...DEF.fields } });
await search.rebuild("companies", docsSource(docs));
return { fake, search };
}
describe("SearchService — definitions", () => {
it("rejects non-text default_search_fields and reserved envelope fields", () => {
const search = new SearchService(new FakeOpenSearch());
expect(() =>
search.registerIndexDefinition({ ...DEF, fields: { name: "keyword" }, default_search_fields: ["name"] })
).toThrowError(/must be a text field/);
expect(() =>
search.registerIndexDefinition({
...DEF,
fields: { ...DEF.fields, tenant_id: "keyword" },
})
).toThrowError(/reserved/);
});
});
describe("SearchService — tenant + purpose/rights enforcement (§10/§31)", () => {
it("returns only the querying tenant's documents", async () => {
const { search } = await build([doc("1", "t_a", "Volvo AB"), doc("2", "t_b", "Volvo Cars")]);
const res = await search.query("companies", {
tenant_id: "t_a",
purpose: "company_enrichment",
text: "volvo",
});
expect(res.total).toBe(1);
expect(res.hits[0].doc_id).toBe("1");
// Envelope fields are stripped from the returned payload.
expect(res.hits[0].payload.tenant_id).toBeUndefined();
});
it("refuses queries without tenant_id or purpose", async () => {
const { search } = await build([doc("1", "t_a", "X")]);
await expect(
search.query("companies", { tenant_id: "", purpose: "company_enrichment" })
).rejects.toMatchObject({ code: "INVALID_REQUEST" });
await expect(search.query("companies", { tenant_id: "t_a", purpose: " " })).rejects.toMatchObject({
code: "INVALID_REQUEST",
});
});
it("purpose filtering: documents not tagged for the query purpose are invisible", async () => {
const { search } = await build([
doc("1", "t_a", "Tagged", { purpose_tags: ["company_enrichment"] }),
doc("2", "t_a", "OtherPurpose", { purpose_tags: ["compliance"] }),
]);
const res = await search.query("companies", { tenant_id: "t_a", purpose: "company_enrichment" });
expect(res.hits.map((h) => h.doc_id)).toEqual(["1"]);
});
it("fails closed: rebuild rejects documents without purpose_tags (§10)", async () => {
const fake = new FakeOpenSearch();
const search = new SearchService(fake);
search.registerIndexDefinition({ ...DEF, fields: { ...DEF.fields } });
await expect(
search.rebuild(
"companies",
docsSource([
doc("1", "t_a", "Ok"),
doc("3", "t_a", "Untagged", { purpose_tags: [] }), // empty ⇒ INVALID_REQUEST, generation discarded
]),
),
).rejects.toThrowError(/missing purpose_tags/);
});
it("rights filtering: default rights tag is 'internal'; deliverable docs need the tag", async () => {
const { search } = await build([
doc("1", "t_a", "Internal", { rights_tags: ["internal"] }),
doc("2", "t_a", "Deliverable", { rights_tags: ["customer_deliverable"] }),
]);
const internal = await search.query("companies", { tenant_id: "t_a", purpose: "company_enrichment" });
expect(internal.hits.map((h) => h.doc_id)).toEqual(["1"]);
const deliverable = await search.query("companies", {
tenant_id: "t_a",
purpose: "company_enrichment",
rights_tag: "customer_deliverable",
});
expect(deliverable.hits.map((h) => h.doc_id)).toEqual(["2"]);
});
it("rejects filter fields not in the index definition", async () => {
const { search } = await build([doc("1", "t_a", "X")]);
await expect(
search.query("companies", {
tenant_id: "t_a",
purpose: "company_enrichment",
filters: { evil_field: "x" },
})
).rejects.toMatchObject({ code: "INVALID_REQUEST" });
});
});
describe("SearchService — generations + rebuild (§42)", () => {
it("rebuild creates g1, a second rebuild creates g2 and switches the alias atomically", async () => {
const { search } = await build([doc("1", "t_a", "First")]);
let state = await search.generationState("companies");
expect(state.active_generation).toBe(1);
const r2 = await search.rebuild("companies", docsSource([doc("1", "t_a", "Second")]));
expect(r2.new_generation).toBe(2);
expect(r2.switched).toBe(true);
state = await search.generationState("companies");
expect(state.active_generation).toBe(2);
// Old generation kept for rollback by default.
expect(state.physical_indices).toContain("opt-companies--g1");
const res = await search.query("companies", { tenant_id: "t_a", purpose: "company_enrichment" });
expect(res.hits[0].payload.name).toBe("Second");
});
it("switchGeneration rolls back to a previous generation; unknown generation is NOT_FOUND", async () => {
const { search } = await build([doc("1", "t_a", "V1")]);
await search.rebuild("companies", docsSource([doc("1", "t_a", "V2")]));
await search.switchGeneration("companies", 1);
const res = await search.query("companies", { tenant_id: "t_a", purpose: "company_enrichment" });
expect(res.hits[0].payload.name).toBe("V1");
await expect(search.switchGeneration("companies", 99)).rejects.toMatchObject({ code: "NOT_FOUND" });
});
it("a failed rebuild discards its generation and leaves the active alias untouched", async () => {
const { fake, search } = await build([doc("1", "t_a", "Stable")]);
// Poison the bulk path for the NEXT generation only.
const origBulk = fake.bulkIndex.bind(fake);
fake.bulkIndex = async (idx, docs) =>
idx.endsWith("--g2") ? { errors: [{ doc_id: "1", error: "mapper_parsing_exception" }] } : origBulk(idx, docs);
await expect(search.rebuild("companies", docsSource([doc("1", "t_a", "Broken")]))).rejects.toMatchObject({
code: "RETRYABLE_FAILURE",
});
const state = await search.generationState("companies");
expect(state.active_generation).toBe(1);
expect(state.physical_indices).not.toContain("opt-companies--g2");
const res = await search.query("companies", { tenant_id: "t_a", purpose: "company_enrichment" });
expect(res.hits[0].payload.name).toBe("Stable");
});
it("indexDocuments validates the envelope and refuses unknown payload fields", async () => {
const { search } = await build([doc("1", "t_a", "X")]);
await expect(
search.indexDocuments("companies", [
{ ...doc("2", "t_a", "Y"), payload: { name: "Y", not_in_def: 1 } },
])
).rejects.toMatchObject({ code: "INVALID_REQUEST" });
await expect(
search.indexDocuments("companies", [{ ...doc("3", "t_a", "Z"), rights_tags: [] }])
).rejects.toMatchObject({ code: "INVALID_REQUEST" });
});
});