/** * REAL Postgres integration test (Master-DoD §48/§50) for the Source * Registry's new persistence layer (src/repositories/*, * sql/002_source_registry.sql) -- the P010 task's central deliverable: this * is what proves the Map -> Postgres migration actually works, not just * that it typechecks. * * Same honest-degrade convention as tests/p0/iceberg-write-service.realinfra.test.ts * and tests/integration/analytics-clickhouse.integration.test.ts: gated on * an env var (SOURCE_REGISTRY_TEST_DATABASE_URL), SKIPS HONESTLY when unset, * never fabricates success. Point it at a disposable Postgres, e.g.: * * docker run -d --name opt-source-registry-pgtest \ * -e POSTGRES_USER=opt -e POSTGRES_PASSWORD=opt_test_pw -e POSTGRES_DB=opt_test \ * -p 15433:5432 postgres:16-alpine * SOURCE_REGISTRY_TEST_DATABASE_URL=postgres://opt:opt_test_pw@localhost:15433/opt_test \ * pnpm vitest run tests/p0/source-registry-postgres.realinfra.test.ts * * This is NOT a mock-repository test -- every assertion below is driven * through SourceRegistryService with `databaseUrl` set, i.e. the real * PostgresSourceRepository/PostgresSourceRegistryRepository HTTP-free SQL * path (postgres.js against the live container), with a handful of * assertions cross-checked with direct SQL against the same database to * prove the rows are really there, not an artifact of the service's own * in-process bookkeeping. * * beforeAll applies sql/002_source_registry.sql itself (every statement is * `CREATE TABLE/INDEX IF NOT EXISTS`, so this is idempotent and safe to run * against an already-migrated database too) -- this test does not require * the operator to have pre-run migrations. */ import { afterAll, beforeAll, describe, expect, it } from "vitest"; import fs from "node:fs"; import path from "node:path"; import postgres from "postgres"; import { SourceRegistryService } from "@/src/services/source-registry-service"; import { closeRepositorySqlForTests } from "@/src/repositories/db"; const TEST_DATABASE_URL = process.env.SOURCE_REGISTRY_TEST_DATABASE_URL; const run = TEST_DATABASE_URL ? describe : describe.skip; let adminSql: ReturnType | undefined; let reachable = false; let unreachableReason = ""; beforeAll(async () => { if (!TEST_DATABASE_URL) { console.warn( "[realinfra] SOURCE_REGISTRY_TEST_DATABASE_URL not set this run -- skipping honestly, not fabricating success.", ); return; } try { adminSql = postgres(TEST_DATABASE_URL, { prepare: false, ssl: false, max: 2 }); await Promise.race([ adminSql`SELECT 1`, new Promise((_, reject) => setTimeout(() => reject(new Error("connect timeout")), 5000)), ]); const migrationPath = path.join(process.cwd(), "sql", "002_source_registry.sql"); const migration = fs.readFileSync(migrationPath, "utf8"); await adminSql.unsafe(migration); reachable = true; } catch (err) { reachable = false; unreachableReason = err instanceof Error ? err.message : String(err); } }, 30000); afterAll(async () => { await adminSql?.end({ timeout: 5 }); await closeRepositorySqlForTests(); }); function svc(): SourceRegistryService { return new SourceRegistryService({ databaseUrl: TEST_DATABASE_URL }); } run("SourceRegistryService against a LIVE Postgres (sql/002_source_registry.sql)", () => { it("persists across independent service instances -- the exact bug this migration fixes (in-memory Maps were per-instance, not even per-process)", async (ctx) => { if (!reachable) { console.warn( `[realinfra] Postgres not reachable this run (${unreachableReason}) -- skipping honestly.`, ); ctx.skip(); return; } const stamp = Date.now(); const sourceId = `src_realpg_${stamp}`; const tenantId = `t_realpg_${stamp}`; const writer = svc(); await writer.registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "api", name: "Live Postgres pilot source", access: "api", created_by: "realinfra-test", rights: { license_id: "official-public-data", allowed_purposes: ["company_enrichment"], pii_allowed: false, redistribution: "customer_deliverable", verified_at: "2026-09-01", verified_by: "realinfra-test", }, provenance: { method: "official_api", authority: "Bolagsverket", cadence: "daily", freshness_sla_hours: 24, }, }); // A BRAND NEW SourceRegistryService, own SourceService/repository // construction under the hood, same DATABASE_URL -- pre-migration this // would see NOTHING (each `new SourceService()` owned a private Map). const reader = svc(); const descriptor = await reader.describeSource(sourceId, tenantId); expect(descriptor.source.source_id).toBe(sourceId); expect(descriptor.source.tenant_id).toBe(tenantId); expect(descriptor.rights?.license_id).toBe("official-public-data"); expect(descriptor.rights?.allowed_purposes).toContain("company_enrichment"); expect(descriptor.provenance?.method).toBe("official_api"); expect(descriptor.provenance?.authority).toBe("Bolagsverket"); // Cross-checked with direct SQL -- real rows, not in-process bookkeeping. const sourceRows = await adminSql!<{ source_id: string; tenant_id: string }[]>` SELECT source_id, tenant_id FROM opt_sources WHERE source_id = ${sourceId}`; expect(sourceRows).toHaveLength(1); expect(sourceRows[0].tenant_id).toBe(tenantId); const rightsRows = await adminSql!<{ license_id: string; allowed_purposes: string[] }[]>` SELECT license_id, allowed_purposes FROM opt_source_rights WHERE source_id = ${sourceId}`; expect(rightsRows).toHaveLength(1); expect(rightsRows[0].license_id).toBe("official-public-data"); expect(rightsRows[0].allowed_purposes).toEqual(["company_enrichment"]); }); it("registering the same source_id twice -> 'already exists', enforced by real Postgres (not app-side memory)", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const sourceId = `src_realpg_dup_${stamp}`; const tenantId = `t_realpg_dup_${stamp}`; await svc().registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "web", name: "First", }); await expect( svc().registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "web", name: "Second", }), ).rejects.toThrow(/already exists/i); }); it("cross-tenant describe -> NOT_FOUND against real Postgres (§50, no existence oracle)", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const sourceId = `src_realpg_tenant_${stamp}`; await svc().registerSource({ source_id: sourceId, tenant_id: `t_a_realpg_${stamp}`, project_id: "p_1", source_type: "web", name: "Tenant A source", }); await expect(svc().describeSource(sourceId, `t_b_realpg_${stamp}`)).rejects.toMatchObject({ code: "NOT_FOUND", }); // And a foreign-tenant query never sees it either. const foreign = await svc().querySources({ tenant_id: `t_b_realpg_${stamp}` }); expect(foreign.find((s) => s.source_id === sourceId)).toBeUndefined(); }); it("purpose gate fail-closed against real Postgres: no rights row denies every purpose", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const sourceId = `src_realpg_norights_${stamp}`; const tenantId = `t_realpg_${stamp}`; await svc().registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "web", name: "No rights yet", }); await expect(svc().assertPurposeAllowed(sourceId, tenantId, "anything")).rejects.toMatchObject({ code: "AUTHORIZATION_DENIED", }); }); it("health checks: bounded to the latest 100 rows in Postgres, consecutive-failure count survives across service instances", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const sourceId = `src_realpg_health_${stamp}`; const tenantId = `t_realpg_${stamp}`; await svc().registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "api", name: "Health test source", }); // 103 "down" checks (oldest -> newest), each via a FRESH service // instance, simulating separate route-handler invocations. for (let i = 0; i < 103; i++) { await svc().recordHealthCheck({ source_id: sourceId, tenant_id: tenantId, status: "down", checked_at: new Date(Date.now() - (300 - i) * 1000).toISOString(), }); } // Then 2 "up" checks, strictly more recent than every "down" above. for (let i = 0; i < 2; i++) { await svc().recordHealthCheck({ source_id: sourceId, tenant_id: tenantId, status: "up", checked_at: new Date(Date.now() - (2 - i) * 500).toISOString(), latency_ms: 42, }); } // Bounded storage: never more than 100 rows for this source_id in Postgres. const countRows = await adminSql!<{ n: number }[]>` SELECT count(*)::int AS n FROM opt_source_health_checks WHERE source_id = ${sourceId}`; expect(countRows[0].n).toBeLessThanOrEqual(100); // All 103 "down" writes plus 2 "up" writes were made; some of the // oldest "down" rows must have been pruned. expect(countRows[0].n).toBeLessThan(105); const health = await svc().getHealth(sourceId, tenantId); expect(health.status).toBe("up"); expect(health.consecutive_failures).toBe(0); const freshness = await svc().getFreshness(sourceId, tenantId); expect(freshness.fresh).toBe(true); expect(freshness.last_success_at).toBeDefined(); }); it("source.query filters by purpose and redistribution against real rows in opt_source_rights", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const tenantId = `t_realpg_query_${stamp}`; const sourceA = `src_realpg_a_${stamp}`; const sourceB = `src_realpg_b_${stamp}`; await svc().registerSource({ source_id: sourceA, tenant_id: tenantId, project_id: "p_1", source_type: "api", name: "A", rights: { license_id: "l1", allowed_purposes: ["company_enrichment"], pii_allowed: false, redistribution: "customer_deliverable", verified_at: "2026-09-01", verified_by: "t", }, }); await svc().registerSource({ source_id: sourceB, tenant_id: tenantId, project_id: "p_1", source_type: "web", name: "B", rights: { license_id: "l2", allowed_purposes: ["compliance"], pii_allowed: false, redistribution: "internal", verified_at: "2026-09-01", verified_by: "t", }, }); const enrichment = await svc().querySources({ tenant_id: tenantId, purpose: "company_enrichment" }); expect(enrichment.map((s) => s.source_id)).toEqual([sourceA]); const internalOnly = await svc().querySources({ tenant_id: tenantId, redistribution: "internal" }); expect(internalOnly.map((s) => s.source_id)).toEqual([sourceB]); }); it("setRights/setProvenance upsert in place (matching the Map.set replace semantics they replace)", async (ctx) => { if (!reachable) return ctx.skip(); const stamp = Date.now(); const sourceId = `src_realpg_upsert_${stamp}`; const tenantId = `t_realpg_${stamp}`; const registry = svc(); await registry.registerSource({ source_id: sourceId, tenant_id: tenantId, project_id: "p_1", source_type: "api", name: "Upsert test", }); await registry.setRights({ source_id: sourceId, tenant_id: tenantId, license_id: "v1", allowed_purposes: ["compliance"], pii_allowed: false, redistribution: "internal", verified_at: "2026-09-01", verified_by: "t", }); await registry.setRights({ source_id: sourceId, tenant_id: tenantId, license_id: "v2", allowed_purposes: ["compliance", "company_enrichment"], pii_allowed: false, redistribution: "customer_deliverable", verified_at: "2026-09-02", verified_by: "t2", }); const rows = await adminSql!< { license_id: string }[] >`SELECT license_id FROM opt_source_rights WHERE source_id = ${sourceId}`; expect(rows).toHaveLength(1); // one row, updated in place -- not two expect(rows[0].license_id).toBe("v2"); const rights = await registry.getRights(sourceId, tenantId); expect(rights?.license_id).toBe("v2"); expect(rights?.allowed_purposes).toEqual(["compliance", "company_enrichment"]); }); });