pedwfrontend/tests/phase22/portal-service-behaviour.test.cjs

const assert = require("assert");
const {
    createAxiosMock,
    createLoggerMock,
    createAxiosError,
    loadServiceModule,
    normalize
} = require("../serviceHarness.cjs");

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

test("portal/sendCaseCompleteMessage appends signed hash suffix to inv query", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();

    const requestCalls = [];
    const requestJson = async (config) => {
        requestCalls.push(config);
        return { status: "ok" };
    };

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        buildHashedQueryUrl: async (queryUrl) => `${queryUrl}&hash=abc123`,
        requestJson
    });

    const result = await portal.sendCaseCompleteMessage(
        "container1",
        "CASE-1",
        "yes"
    );

    assert.deepStrictEqual(normalize(result), { status: "ok" });
    assert.strictEqual(requestCalls.length, 1);
    assert.strictEqual(requestCalls[0].method, "get");
    assert.strictEqual(
        requestCalls[0].url,
        "/api/file/createappealcompletemessage_api?container=container1&tempcaseref=CASE-1&inv=yes&hash=abc123"
    );
});

test("portal/deleteMyRepresentations uses signed delete request with headers", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();

    const requestCalls = [];
    const requestJson = async (config) => {
        requestCalls.push(config);
        return { deleted: true };
    };

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        buildHashedQueryUrl: async (queryUrl) => `${queryUrl}&hash=xyz`,
        requestJson
    });

    const result = await portal.deleteMyRepresentations("rep-1");

    assert.deepStrictEqual(normalize(result), { deleted: true });
    assert.strictEqual(requestCalls.length, 1);
    assert.strictEqual(requestCalls[0].method, "delete");
    assert.strictEqual(
        requestCalls[0].url,
        "/api/endpoint/deletemyrepresentations_api?myRepresentationsID=rep-1&hash=xyz"
    );
    assert.strictEqual(
        requestCalls[0].headers["Content-Type"],
        "application/json"
    );
});

test("portal/createWatchedCases posts to harmonized route helper URL", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();

    const requestCalls = [];
    const requestJson = async (config) => {
        requestCalls.push(config);
        return { created: true };
    };

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        requestJson
    });

    const payload = { foo: "bar" };
    const result = await portal.createWatchedCases(payload);

    assert.deepStrictEqual(normalize(result), { created: true });
    assert.strictEqual(requestCalls.length, 1);
    assert.strictEqual(requestCalls[0].method, "post");
    assert.strictEqual(
        requestCalls[0].url,
        "/api/subscriptions/create-watched-case"
    );
    assert.deepStrictEqual(normalize(requestCalls[0].data), payload);
});

test("portal/sendRepCompleteMessage rejects when hash signing fails before request stage", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();
    const error = createAxiosError(500, "Failed");

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        buildHashedQueryUrl: async () => {
            throw error;
        },
        requestJson: async () => {
            throw new Error("should not be called");
        }
    });

    await assert.rejects(
        () => portal.sendRepCompleteMessage("c", "r", "f"),
        (caught) => {
            assert.strictEqual(caught, error);
            return true;
        }
    );

    assert.strictEqual(logger.calls.length, 0);
});

test("portal/sendRepCompleteMessage requests signed URL from shared signed helper", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();

    const signedCalls = [];
    const requestCalls = [];

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        buildSignedUrl: async (queryUrl) => {
            signedCalls.push(queryUrl);
            return `${queryUrl}&hash=signed-portal`;
        },
        requestJson: async (config) => {
            requestCalls.push(config);
            return { ok: true };
        }
    });

    const result = await portal.sendRepCompleteMessage(
        "container-x",
        "CASE-99",
        "rep-a"
    );

    assert.deepStrictEqual(normalize(result), { ok: true });
    assert.strictEqual(signedCalls.length, 1);
    assert.strictEqual(
        signedCalls[0],
        "/api/file/createrepcompletemessage_api?container=container-x&tempcaseref=CASE-99&repid=rep-a"
    );
    assert.strictEqual(requestCalls.length, 1);
    assert.strictEqual(requestCalls[0].method, "get");
    assert.strictEqual(
        requestCalls[0].url,
        "/api/file/createrepcompletemessage_api?container=container-x&tempcaseref=CASE-99&repid=rep-a&hash=signed-portal"
    );
});

test("portal/deleteWatchedCases logs and returns undefined when signed delete fails", async () => {
    const axios = createAxiosMock();
    const logger = createLoggerMock();
    const error = createAxiosError(401, "Unauthorized");

    const portal = loadServiceModule("portalDirectService.js", {
        axios,
        BASE_URL: "",
        consoleLogger: logger.consoleLogger,
        deleteSignedJson: async () => {
            throw error;
        }
    });

    const result = await portal.deleteWatchedCases("watch-2");

    assert.strictEqual(result, undefined);
    assert.strictEqual(logger.calls.length, 1);
    assert.strictEqual(logger.calls[0], error);
});

const run = async () => {
    let passed = 0;

    for (const currentTest of tests) {
        await currentTest.fn();
        passed += 1;
    }

    console.log(
        `Phase 22 portal-service tests passed (${passed}/${tests.length}).`
    );
};

module.exports = run;

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