pedwfrontend/tests/phase21/email-handler-contract.test.cjs

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

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

test("getevents returns INCIDENT_ID_REQUIRED when incidentID missing", async () => {
    const mod = loadModule("pages/api/email/getevents.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: { get: async () => ({ data: { value: [] } }) },
        _: { get: (obj, key, fallback) => obj?.data?.value || fallback },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(res.state.jsonBody.error.code, "INCIDENT_ID_REQUIRED");
});

test("getevents returns SIPS_RECORD_NOT_FOUND when linked record is missing", async () => {
    const mod = loadModule("pages/api/email/getevents.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: { get: async () => ({ data: { value: [] } }) },
        _: { get: (obj, key, fallback) => obj?.data?.value || fallback },
        consoleLogger: () => {}
    });

    const req = { query: { incidentID: "123" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 404);
    assert.strictEqual(res.state.jsonBody.error.code, "SIPS_RECORD_NOT_FOUND");
});

test("getevents dependency failure returns EVENTS_FETCH_FAILED", async () => {
    const mod = loadModule("pages/api/email/getevents.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: {
            get: async () => {
                throw new Error("upstream failed");
            }
        },
        _: { get: (obj, key, fallback) => obj?.data?.value || fallback },
        consoleLogger: () => {}
    });

    const req = { query: { incidentID: "123" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 500);
    assert.strictEqual(res.state.jsonBody.error.code, "EVENTS_FETCH_FAILED");
});

test("getdocuments returns INCIDENT_ID_REQUIRED when incidentid missing", async () => {
    const mod = loadModule("pages/api/email/getdocuments.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeadersPaged: () => ({}),
        axios: { get: async () => ({ data: { value: [] } }) },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(res.state.jsonBody.error.code, "INCIDENT_ID_REQUIRED");
});

test("getdocuments dependency failure returns DOCUMENTS_FETCH_FAILED", async () => {
    const mod = loadModule("pages/api/email/getdocuments.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeadersPaged: () => ({}),
        axios: {
            get: async () => {
                throw new Error("docs failed");
            }
        },
        consoleLogger: () => {}
    });

    const req = { query: { incidentid: "123" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 500);
    assert.strictEqual(res.state.jsonBody.error.code, "DOCUMENTS_FETCH_FAILED");
});

test("getall top-level failure returns EMAIL_COMBINED_FETCH_FAILED", async () => {
    const mod = loadModule("pages/api/email/getall.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => {
            throw new Error("token failed");
        },
        consoleLogger: () => {},
        formatDates: () => "01/01/2026",
        NotifyClient: function NotifyClient() {
            return { sendEmail: async () => ({ id: "n1" }) };
        },
        require: (name) => {
            if (name === "notifications-node-client") {
                return {
                    NotifyClient: function NotifyClient() {
                        return { sendEmail: async () => ({ id: "n1" }) };
                    }
                };
            }
            return require(name);
        }
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 500);
    assert.strictEqual(
        res.state.jsonBody.error.code,
        "EMAIL_COMBINED_FETCH_FAILED"
    );
});

test("getmailinglist success returns flattened mailing list results", async () => {
    const mod = loadModule("pages/api/email/getmailinglist.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: {
            get: async () => ({
                data: {
                    value: [
                        {
                            pinswg_emailnotifications: true,
                            pinswg_Contact: {
                                contactid: "c1",
                                emailaddress1: "a@test.local"
                            }
                        }
                    ]
                }
            })
        },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.deepStrictEqual(JSON.parse(JSON.stringify(res.state.jsonBody)), [
        {
            pinswg_emailnotifications: true,
            contactid: "c1",
            contact_email: "a@test.local"
        }
    ]);
});

test("getmailinglist failure returns MAILING_LIST_FETCH_FAILED", async () => {
    const mod = loadModule("pages/api/email/getmailinglist.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: {
            get: async () => {
                throw new Error("mailing list failed");
            }
        },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(
        res.state.jsonBody.error.code,
        "MAILING_LIST_FETCH_FAILED"
    );
});

test("getcaseref success returns flattened case ref results", async () => {
    const mod = loadModule("pages/api/email/getcaseref.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: {
            get: async () => ({
                data: {
                    value: [
                        {
                            pinswg_emailnotifications: true,
                            pinswg_Contact: {
                                contactid: "c2",
                                emailaddress1: "b@test.local"
                            }
                        }
                    ]
                }
            })
        },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.deepStrictEqual(JSON.parse(JSON.stringify(res.state.jsonBody)), [
        {
            pinswg_emailnotifications: true,
            contactid: "c2",
            contact_email: "b@test.local"
        }
    ]);
});

test("getcaseref failure returns CASE_REF_FETCH_FAILED", async () => {
    const mod = loadModule("pages/api/email/getcaseref.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getToken: async () => ({ access_token: "token" }),
        hashAPIPath: () => "&hash=expected",
        azureHeaders: () => ({}),
        axios: {
            get: async () => {
                throw new Error("case ref failed");
            }
        },
        consoleLogger: () => {}
    });

    const req = { query: {} };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(res.state.jsonBody.error.code, "CASE_REF_FETCH_FAILED");
});

test("notify returns EMAIL_ADDRESS_REQUIRED when emailAddress is missing", async () => {
    const mod = loadModule("pages/api/email/notify.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        consoleLogger: () => {},
        redactSensitive: (value) => value,
        sanitizeString: () => "",
        isNonEmptyString: () => false,
        getPreferredLanguage: async () => ({ value: [] })
    });

    const req = { body: { templateId: "t1", reference: "OTHER" } };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(res.state.jsonBody.error.code, "EMAIL_ADDRESS_REQUIRED");
});

test("notify send failure returns EMAIL_NOTIFY_FAILED", async () => {
    const mod = loadModule("pages/api/email/notify.js", {
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        consoleLogger: () => {},
        redactSensitive: (value) => value,
        sanitizeString: (value) => value,
        isNonEmptyString: () => true,
        getPreferredLanguage: async () => ({ value: [] }),
        require: (name) => {
            if (name === "notifications-node-client") {
                return {
                    NotifyClient: function NotifyClient() {
                        return {
                            sendEmail: async () => {
                                throw new Error("notify failed");
                            }
                        };
                    }
                };
            }

            return require(name);
        }
    });

    const req = {
        body: {
            templateId: "t1",
            emailAddress: "user@test.local",
            personalisation: {},
            reference: "OTHER"
        }
    };
    const res = createRes();
    await mod.default(req, res);

    assert.strictEqual(res.state.statusCode, 400);
    assert.strictEqual(res.state.jsonBody.error.code, "EMAIL_NOTIFY_FAILED");
});

const run = async () => {
    let passed = 0;
    for (const currentTest of tests) {
        await currentTest.fn();
        passed += 1;
    }
    console.log(
        `Phase 21 email-handler contract tests passed (${passed}/${tests.length}).`
    );
};

module.exports = run;

if (require.main === module) {
    run().catch((error) => {
        console.error(error);
        process.exit(1);
    });
}