pedwfrontend/tests/phase22/representation-window.test.cjs

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

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

const createFakeDate = (isoString) => {
    const RealDate = Date;

    function FakeDate(...args) {
        if (!(this instanceof FakeDate)) {
            return new RealDate(...args);
        }

        if (args.length === 0) {
            return new RealDate(isoString);
        }

        return new RealDate(...args);
    }

    FakeDate.UTC = RealDate.UTC;
    FakeDate.parse = RealDate.parse;
    FakeDate.now = () => new RealDate(isoString).getTime();
    FakeDate.prototype = RealDate.prototype;

    return FakeDate;
};

const loadRepresentationWindowModule = () => {
    const filePath = path.join(
        rootDir,
        "lib",
        "domain",
        "representation-policy",
        "resolveRepresentationWindow.js"
    );

    let source = fs.readFileSync(filePath, "utf8");
    source = source.replace(
        /export function\s+isRepresentationWindowOpen/,
        "function isRepresentationWindowOpen"
    );
    source = source.replace(
        /export function\s+isRepresentationWindowClosed/,
        "function isRepresentationWindowClosed"
    );
    source = source.replace(
        /export function\s+resolveRepresentationWindow/,
        "function resolveRepresentationWindow"
    );
    source += `
module.exports = {
  isRepresentationWindowOpen,
  isRepresentationWindowClosed,
  resolveRepresentationWindow
};
`;

    const context = {
        module: { exports: {} },
        exports: {},
        require,
        Date
    };

    vm.runInNewContext(source, context, { filename: filePath });
    return context.module.exports;
};

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

const {
    isRepresentationWindowOpen,
    isRepresentationWindowClosed,
    resolveRepresentationWindow
} = loadRepresentationWindowModule();

test("general window is open when today falls inclusively between start and end", () => {
    const FakeDate = createFakeDate("2026-04-15T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_startdate: "2026-04-01T00:00:00.000Z",
            pinswg_finalcommentsduedate: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.hasStartDate, true);
    assert.strictEqual(result.startDate, "2026-04-01T00:00:00.000Z");
    assert.strictEqual(result.endDate, "2026-04-30T00:00:00.000Z");
    assert.strictEqual(result.isOpen, true);
    assert.strictEqual(result.isClosed, false);
});

test("general window is not open before the start date", () => {
    const FakeDate = createFakeDate("2026-03-31T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_startdate: "2026-04-01T00:00:00.000Z",
            pinswg_finalcommentsduedate: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.isOpen, false);
    assert.strictEqual(result.isClosed, false);
});

test("general window is closed after the end date", () => {
    const FakeDate = createFakeDate("2026-05-01T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_startdate: "2026-04-01T00:00:00.000Z",
            pinswg_finalcommentsduedate: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.isOpen, false);
    assert.strictEqual(result.isClosed, true);
});

test("missing start-related properties preserve false open state", () => {
    const FakeDate = createFakeDate("2026-04-15T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_finalcommentsduedate: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.hasStartDate, false);
    assert.strictEqual(result.startDate, undefined);
    assert.strictEqual(result.endDate, "2026-04-30T00:00:00.000Z");
    assert.strictEqual(result.isOpen, false);
    assert.strictEqual(result.isClosed, false);
});

test("future window from fallback startdate field preserves open=false closed=false", () => {
    const FakeDate = createFakeDate("2026-04-15T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_startdates: "2026-04-20T00:00:00.000Z",
            pinswg_finalcommentsduedate: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.startDate, "2026-04-20T00:00:00.000Z");
    assert.strictEqual(result.isOpen, false);
    assert.strictEqual(result.isClosed, false);
});

test("application accepted as valid is used as fallback start date with representation-period end date", () => {
    const FakeDate = createFakeDate("2026-04-15T10:00:00.000Z");
    const result = resolveRepresentationWindow(
        {
            pinswg_applicationacceptedasvalid: "2026-04-01T00:00:00.000Z",
            pinswg_endofrepresentationperiod: "2026-04-30T00:00:00.000Z"
        },
        FakeDate
    );

    assert.strictEqual(result.startDate, "2026-04-01T00:00:00.000Z");
    assert.strictEqual(result.endDate, "2026-04-30T00:00:00.000Z");
    assert.strictEqual(result.isOpen, true);
    assert.strictEqual(result.isClosed, false);
});

test("consultation-like direct window helpers preserve inclusive same-day opening behaviour", () => {
    const FakeDate = createFakeDate("2026-04-30T10:00:00.000Z");

    assert.strictEqual(
        isRepresentationWindowOpen(
            "2026-04-01T00:00:00.000Z",
            "2026-04-30T00:00:00.000Z",
            FakeDate
        ),
        true
    );
    assert.strictEqual(
        isRepresentationWindowClosed(
            "2026-04-01T00:00:00.000Z",
            "2026-04-30T00:00:00.000Z",
            FakeDate
        ),
        false
    );
});

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

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

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

module.exports = run;

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