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

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

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

test("upload handler returns HASH_REQUIRED for missing hash", async () => {
    const mod = loadModule("pages/api/file/upload.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "?hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createBlob: async () => ({ ok: true }),
        createRepBlob: async () => ({ ok: true })
    });

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

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

test("upload handler returns INVALID_HASH for wrong hash", async () => {
    const mod = loadModule("pages/api/file/upload.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "?hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createBlob: async () => ({ ok: true }),
        createRepBlob: async () => ({ ok: true })
    });

    const req = {
        query: { hash: "wrong" },
        body: { containerID: ["c1"], casefolderID: ["f1"] }
    };
    const res = createRes();
    await mod.default.handler(req, res);

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

test("deleteblob handler returns MISSING_REQUIRED_QUERY when blobname missing", async () => {
    const mod = loadModule("pages/api/file/deleteblob.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        deleteBlob: async () => ({ ok: true })
    });

    const req = {
        query: { container: "c1", casefolderID: "f1", hash: "expected" }
    };
    const res = createRes();
    await mod.default.handler(req, res);

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

test("getbloblist handler returns INVALID_HASH for mismatch", async () => {
    const mod = loadModule("pages/api/file/getbloblist.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getBlobs: async () => ({ id: "x" }),
        getRepsFilesBlobs: async () => ({ id: "x" })
    });

    const req = {
        query: { container: "c1", casefolderID: "f1", hash: "wrong" }
    };
    const res = createRes();
    await mod.default.handler(req, res);

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

test("setupcontainer handler returns MISSING_REQUIRED_QUERY when ident missing", async () => {
    const mod = loadModule("pages/api/file/setupcontainer.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        consoleLogger: () => {},
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createContainer: async () => ({ ok: true })
    });

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

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

test("upload handler success returns data payload with 200", async () => {
    const mod = loadModule("pages/api/file/upload.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "?hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createBlob: async () => ({ id: "blob-1" }),
        createRepBlob: async () => ({ id: "rep-1" })
    });

    const req = {
        query: { hash: "expected" },
        body: {
            appealData: { key: "value" },
            containerID: ["c1"],
            casefolderID: ["f1"],
            repOrAppeal: false
        }
    };
    const res = createRes();
    await mod.default.handler(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.deepStrictEqual(JSON.parse(JSON.stringify(res.state.jsonBody)), {
        data: { id: "blob-1" }
    });
});

test("setupcontainer handler success returns expected contract", async () => {
    const mod = loadModule("pages/api/file/setupcontainer.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        consoleLogger: () => {},
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createContainer: async () => ({ created: true })
    });

    const req = { query: { ident: "cont-1", hash: "expected" } };
    const res = createRes();
    await mod.default.handler(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.deepStrictEqual(JSON.parse(JSON.stringify(res.state.jsonBody)), {
        data: "success",
        output: { created: true }
    });
});

test("getbloblist handler success returns value array contract", async () => {
    const mod = loadModule("pages/api/file/getbloblist.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        getBlobs: async () => ({ file: "a.pdf" }),
        getRepsFilesBlobs: async () => ({ file: "rep.pdf" })
    });

    const req = {
        query: { container: "c1", casefolderID: "f1", hash: "expected" }
    };
    const res = createRes();
    await mod.default.handler(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.deepStrictEqual(JSON.parse(JSON.stringify(res.state.jsonBody)), {
        value: [{ file: "a.pdf" }]
    });
});

test("downloadblob handler success sets attachment header and returns body", async () => {
    const mod = loadModule("pages/api/file/downloadblob.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        respondError: respondErrorMock,
        downloadFile: async () => Buffer.from("file-content")
    });

    const req = {
        query: {
            container: "c1",
            casefolderID: "f1",
            blobname: "doc.pdf",
            hash: "expected"
        }
    };
    const res = createRes();
    await mod.default.handler(req, res);

    assert.strictEqual(res.state.statusCode, 200);
    assert.strictEqual(
        res.state.headers["content-disposition"],
        "attachment; filename=doc.pdf"
    );
    assert.strictEqual(res.state.sentBody.toString(), "file-content");
});

test("upload handler dependency failure returns UPLOAD_FAILED", async () => {
    const mod = loadModule("pages/api/file/upload.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "?hash=expected",
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createBlob: async () => {
            throw new Error("storage down");
        },
        createRepBlob: async () => ({ id: "rep-1" })
    });

    const req = {
        query: { hash: "expected" },
        body: {
            appealData: { key: "value" },
            containerID: ["c1"],
            casefolderID: ["f1"],
            repOrAppeal: false
        }
    };
    const res = createRes();
    await mod.default.handler(req, res);

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

test("setupcontainer dependency failure returns SETUP_CONTAINER_FAILED", async () => {
    const mod = loadModule("pages/api/file/setupcontainer.js", {
        nextConnect: createNextConnectMock(),
        middleware: () => {},
        hashAPIPath: () => "&hash=expected",
        consoleLogger: () => {},
        respondError: respondErrorMock,
        respondSuccess: respondSuccessMock,
        createContainer: async () => {
            throw new Error("container failed");
        }
    });

    const req = { query: { ident: "cont-1", hash: "expected" } };
    const res = createRes();
    await mod.default.handler(req, res);

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

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

module.exports = run;

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