pedwfrontend/tests/phase22/api-grouping-facade-case-details.test.cjs

const assert = require("assert");
const fs = require("fs");
const path = require("path");

const { loadModule, createRes } = require("../phase21/_shared.cjs");

const rootDir = path.resolve(__dirname, "..", "..");

const tests = [];
const test = (name, fn) => tests.push({ name, fn });

const read = (relativePath) =>
    fs.readFileSync(path.join(rootDir, relativePath), "utf8");

test("cases get-incident-by-id facade delegates to legacy handler", async () => {
    const calls = [];
    const mod = loadModule("pages/api/cases/get-incident-by-id.js", {
        legacyGetIncidentByIdHandler: async (req, res) => {
            calls.push({ req, res });
            return res.status(200).json({ ok: true, route: "incident-by-id" });
        }
    });

    const req = { method: "GET", query: { searchString: "abc-123" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(calls.length, 1);
    assert.strictEqual(calls[0].req, req);
    assert.strictEqual(calls[0].res, res);
});

test("cases get-case-message facade delegates to legacy handler", async () => {
    const calls = [];
    const mod = loadModule("pages/api/cases/get-case-message.js", {
        legacyGetCaseMessageHandler: async (req, res) => {
            calls.push({ req, res });
            return res.status(200).json({ ok: true, route: "case-message" });
        }
    });

    const req = { method: "GET", query: { id: "case-1" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(calls.length, 1);
    assert.strictEqual(calls[0].req, req);
    assert.strictEqual(calls[0].res, res);
});

test("cases get-linked-cases facade delegates to legacy handler", async () => {
    const calls = [];
    const mod = loadModule("pages/api/cases/get-linked-cases.js", {
        legacyGetLinkedCasesHandler: async (req, res) => {
            calls.push({ req, res });
            return res.status(200).json({ ok: true, route: "linked-cases" });
        }
    });

    const req = { method: "GET", query: { parentincidentid: "parent-1" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(calls.length, 1);
    assert.strictEqual(calls[0].req, req);
    assert.strictEqual(calls[0].res, res);
});

test("cases get-sips-events facade delegates to legacy handler", async () => {
    const calls = [];
    const mod = loadModule("pages/api/cases/get-sips-events.js", {
        legacyGetSipsEventsHandler: async (req, res) => {
            calls.push({ req, res });
            return res.status(200).json({ ok: true, route: "sips-events" });
        }
    });

    const req = { method: "GET", query: { caseid: "sips-1" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(calls.length, 1);
    assert.strictEqual(calls[0].req, req);
    assert.strictEqual(calls[0].res, res);
});

test("cases get-sips-media facade delegates to legacy handler", async () => {
    const calls = [];
    const mod = loadModule("pages/api/cases/get-sips-media.js", {
        legacyGetSipsMediaHandler: async (req, res) => {
            calls.push({ req, res });
            return res.status(200).json({ ok: true, route: "sips-media" });
        }
    });

    const req = { method: "GET", query: { caseid: "sips-2" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(calls.length, 1);
    assert.strictEqual(calls[0].req, req);
    assert.strictEqual(calls[0].res, res);
});

test("legacy case-details endpoint handlers remain present", async () => {
    const legacyFiles = [
        "pages/api/endpoint/getincidentbyid_api.js",
        "pages/api/endpoint/getcasemessage_api.js",
        "pages/api/endpoint/getlinkedcases_api.js",
        "pages/api/endpoint/getsipsevents_api.js",
        "pages/api/endpoint/getsipsmedia_api.js",
        "pages/api/endpoint/getbasicsearch_api.js",
        "pages/api/endpoint/getbasicsearchdetails_api.js",
        "pages/api/endpoint/getsearchdocumentdetails_api.js"
    ];

    legacyFiles.forEach((filePath) => {
        assert.strictEqual(
            fs.existsSync(path.join(rootDir, filePath)),
            true,
            filePath
        );
    });
});

test("caseDirectService adopted case-details reads now target grouped cases routes", async () => {
    const source = read("actions/services/caseDirectService.js");

    assert.match(source, /\/api\/cases\/get-incident-by-id/);
    assert.match(source, /\/api\/cases\/get-case-message/);
    assert.match(source, /\/api\/cases\/get-sips-events/);
    assert.match(source, /\/api\/cases\/get-sips-media/);
});

test("searchDirectService linked-cases read now targets grouped cases route", async () => {
    const source = read("actions/services/searchDirectService.js");

    assert.match(source, /\/api\/cases\/get-linked-cases\?/);
});

test("case-details service contracts remain unchanged", async () => {
    const caseSource = read("actions/services/caseDirectService.js");
    const searchSource = read("actions/services/searchDirectService.js");

    assert.match(caseSource, /id: searchString/);
    assert.match(caseSource, /searchString/);
    assert.match(caseSource, /caseid/);
    assert.match(searchSource, /parentincidentid=/);
});

test("adjacent search and documents routes remain outside case-details adoption scope", async () => {
    const caseSource = read("actions/services/caseDirectService.js");
    const searchSource = read("actions/services/searchDirectService.js");

    assert.match(searchSource, /\/api\/endpoint\/getbasicsearch_api/);
    assert.match(searchSource, /\/api\/endpoint\/getbasicsearchdetails_api/);
    assert.match(
        searchSource,
        /\/api\/documents\/get-search-document-details\?/
    );
    assert.doesNotMatch(caseSource, /\/api\/cases\/get-case"/);
    assert.doesNotMatch(caseSource, /\/api\/cases\/get-case-by-id/);
});

async function run() {
    let failures = 0;

    for (const { name, fn } of tests) {
        try {
            await fn();
            console.log(`✓ ${name}`);
        } catch (error) {
            failures += 1;
            console.error(`✗ ${name}`);
            console.error(error);
        }
    }

    if (failures > 0) {
        process.exit(1);
    }
}

run();