Robert Bond
9595ad86df
# Summary This PR introduces a **Case Lifecycle Domain Boundary** to centralize lifecycle decision logic and reduce coupling within the appeals application. The work is **behaviour-preserving** and introduces no intentional changes to business rules, CRM integrations, translations, dashboards, API routes, or user-facing functionality. ## What was added New lifecycle boundary: ```text lib/domain/case-lifecycle/ ``` Key responsibilities extracted: - Specialist process normalization - Appeal type mapping - Specialist process stage override mapping - Stage case-type resolution - Stage catalogue lookup - Closed-case status recognition - Lifecycle stage index resolution - Lifecycle stage status assignment ## Behaviour preserved Characterization tests were added before each extraction to preserve: - Appeal type mapping and aliases - Specialist process handling - Lifecycle stage progression - Closed-case handling - Status assignment (`complete`, `in-progress`, `not-started`) - Existing ROW behaviour - Existing `statuscode` lifecycle semantics Closed-case recognition remains unchanged for: ```text 1000 5 6 846040013 846040059 846040060 ``` ## Documentation Added: ```text lib/domain/case-lifecycle/README.md ``` Documenting: - Boundary ownership - Non-goals - Lifecycle invariants - Known architectural constraints - Future extraction roadmap ## Testing Added lifecycle characterization coverage for: - Stage wrapper behaviour - Specialist process normalization - Appeal type mapping - Specialist process stage mapping - Stage case-type resolution - Stage catalogue lookup - Progress behaviour - Closed-case status handling - Stage index resolution - Stage status assignment ## Validation - Lifecycle characterization tests passed - `npm run lint` passed with no errors ## Out of Scope No changes to: - Stage catalogue ownership - Representation eligibility - Dashboard calculations - CRM/OData queries - API routes - Redux state - EN/CY translations - Event visibility logic ## Risk **Low risk** The refactor was delivered through small, characterization-first slices with no functional changes intended. Related work items: #23527
460 lines
13 KiB
JavaScript
460 lines
13 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
const vm = require("vm");
|
|
const assert = require("assert");
|
|
|
|
const rootDir = path.resolve(__dirname, "..", "..");
|
|
|
|
const loadStageHelperModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"components",
|
|
"case",
|
|
"summary",
|
|
"utils",
|
|
"caseStagesByAppealType.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/import[\s\S]*?from\s+"[^"]+";\n?/g, "");
|
|
source = source.replace(/export const\s+/g, "const ");
|
|
source += `
|
|
module.exports = {
|
|
getStagesForAppealType,
|
|
stagesByCaseType
|
|
};
|
|
`;
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require,
|
|
getStageCaseTypeKey: getStageCaseTypeKeyModule.getStageCaseTypeKey,
|
|
getStagesForCaseTypeKey:
|
|
getStagesForCaseTypeKeyModule.getStagesForCaseTypeKey
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const loadWrapperModule = (stageHelperModule) => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"lib",
|
|
"domain",
|
|
"case-lifecycle",
|
|
"getLifecycleStagesForCase.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(
|
|
/import\s+\{\s*getStagesForAppealType\s*\}\s+from\s+"[^"]+";\n?/,
|
|
""
|
|
);
|
|
source = source.replace(
|
|
/export function\s+getLifecycleStagesForCase/,
|
|
"function getLifecycleStagesForCase"
|
|
);
|
|
source += "\nmodule.exports = { getLifecycleStagesForCase };\n";
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require,
|
|
getStagesForAppealType: stageHelperModule.getStagesForAppealType
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const tests = [];
|
|
const test = (name, fn) => tests.push({ name, fn });
|
|
|
|
const normalizeForAssertion = (value) =>
|
|
JSON.parse(JSON.stringify(value ?? null));
|
|
|
|
const loadMapAppealTypeModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"lib",
|
|
"domain",
|
|
"case-lifecycle",
|
|
"mapAppealType.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/export const\s+/g, "const ");
|
|
source = source.replace(
|
|
/export function\s+mapAppealType/,
|
|
"function mapAppealType"
|
|
);
|
|
source += `
|
|
module.exports = {
|
|
caseTypeAliases,
|
|
caseTypeKeyByAppealTypeId,
|
|
normaliseCaseType,
|
|
mapAppealType
|
|
};
|
|
`;
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const loadMapSpecialistProcessStageTypeModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"lib",
|
|
"domain",
|
|
"case-lifecycle",
|
|
"mapSpecialistProcessStageType.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/export const\s+/g, "const ");
|
|
source = source.replace(
|
|
/export function\s+mapSpecialistProcessStageType/,
|
|
"function mapSpecialistProcessStageType"
|
|
);
|
|
source += `
|
|
module.exports = {
|
|
specialistProcessStageTypeByCaseType,
|
|
mapSpecialistProcessStageType
|
|
};
|
|
`;
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const loadGetStageCaseTypeKeyModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"lib",
|
|
"domain",
|
|
"case-lifecycle",
|
|
"getStageCaseTypeKey.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/import[\s\S]*?from\s+"[^"]+";\n?/g, "");
|
|
source = source.replace(
|
|
/export function\s+getStageCaseTypeKey/,
|
|
"function getStageCaseTypeKey"
|
|
);
|
|
source += `
|
|
module.exports = {
|
|
getStageCaseTypeKey
|
|
};
|
|
`;
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require,
|
|
caseTypeAliases: mapAppealTypeModule.caseTypeAliases,
|
|
caseTypeKeyByAppealTypeId:
|
|
mapAppealTypeModule.caseTypeKeyByAppealTypeId,
|
|
mapAppealType: mapAppealTypeModule.mapAppealType,
|
|
normaliseCaseType: mapAppealTypeModule.normaliseCaseType,
|
|
mapSpecialistProcessStageType:
|
|
mapSpecialistProcessStageTypeModule.mapSpecialistProcessStageType
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const loadGetStagesForCaseTypeKeyModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"lib",
|
|
"domain",
|
|
"case-lifecycle",
|
|
"getStagesForCaseTypeKey.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/import[\s\S]*?from\s+"[^"]+";\n?/g, "");
|
|
source = source.replace(
|
|
/export function\s+getStagesForCaseTypeKey/,
|
|
"function getStagesForCaseTypeKey"
|
|
);
|
|
source += `
|
|
module.exports = {
|
|
getStagesForCaseTypeKey
|
|
};
|
|
`;
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require: (modulePath) => {
|
|
if (
|
|
modulePath ===
|
|
"../../../components/case/summary/utils/caseStagesByAppealType"
|
|
) {
|
|
return stageCatalogueModule;
|
|
}
|
|
|
|
return require(modulePath);
|
|
}
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const loadStageCatalogueModule = () => {
|
|
const filePath = path.join(
|
|
rootDir,
|
|
"components",
|
|
"case",
|
|
"summary",
|
|
"utils",
|
|
"caseStagesByAppealType.js"
|
|
);
|
|
|
|
let source = fs.readFileSync(filePath, "utf8");
|
|
source = source.replace(/import[\s\S]*?from\s+"[^"]+";\n?/g, "");
|
|
source = source.replace(/export const\s+/g, "const ");
|
|
source += "\nmodule.exports = { stagesByCaseType };\n";
|
|
|
|
const context = {
|
|
module: { exports: {} },
|
|
exports: {},
|
|
require,
|
|
getStageCaseTypeKey: getStageCaseTypeKeyModule.getStageCaseTypeKey,
|
|
getStagesForCaseTypeKey: () => []
|
|
};
|
|
|
|
vm.runInNewContext(source, context, { filename: filePath });
|
|
return context.module.exports;
|
|
};
|
|
|
|
const mapAppealTypeModule = loadMapAppealTypeModule();
|
|
const mapSpecialistProcessStageTypeModule =
|
|
loadMapSpecialistProcessStageTypeModule();
|
|
const getStageCaseTypeKeyModule = loadGetStageCaseTypeKeyModule();
|
|
const stageCatalogueModule = loadStageCatalogueModule();
|
|
const getStagesForCaseTypeKeyModule = loadGetStagesForCaseTypeKeyModule();
|
|
const stageHelperModule = loadStageHelperModule();
|
|
const wrapperModule = loadWrapperModule(stageHelperModule);
|
|
|
|
const { getStagesForAppealType } = stageHelperModule;
|
|
const { getLifecycleStagesForCase } = wrapperModule;
|
|
|
|
test("S78 early-stage progression preserves stage ordering and statuses", () => {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040000, 846040014)
|
|
);
|
|
|
|
assert.ok(Array.isArray(result));
|
|
assert.strictEqual(result[0].stageId, 846040014);
|
|
assert.strictEqual(result[0].titleKey, "appeal-submitted");
|
|
assert.strictEqual(result[0].status, "in-progress");
|
|
assert.strictEqual(result[1].status, "not-started");
|
|
assert.strictEqual(result[result.length - 1].titleKey, "case-closed");
|
|
});
|
|
|
|
test("S78 mid-stage progression preserves completed/current/future status split", () => {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040000, 846040018)
|
|
);
|
|
|
|
const currentStage = result.find((stage) => stage.stageId === 846040018);
|
|
|
|
assert.ok(currentStage);
|
|
assert.strictEqual(result[0].status, "complete");
|
|
assert.strictEqual(currentStage.status, "in-progress");
|
|
assert.strictEqual(result[result.length - 1].status, "not-started");
|
|
});
|
|
|
|
test("DNS stage mapping remains unchanged", () => {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040011, 846040006)
|
|
);
|
|
|
|
assert.deepStrictEqual(
|
|
result.map((stage) => stage.stageId),
|
|
[
|
|
846040001, 846040002, 846040003, 846040004, 846040005, 846040006,
|
|
846040007, 846040008, 846040009, 846040011, 846040012, 846040013
|
|
]
|
|
);
|
|
assert.strictEqual(
|
|
result.find((stage) => stage.stageId === 846040006).status,
|
|
"in-progress"
|
|
);
|
|
});
|
|
|
|
test("Householder stage mapping remains unchanged", () => {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040004, 846040021)
|
|
);
|
|
|
|
assert.deepStrictEqual(
|
|
result.map((stage) => stage.stageId),
|
|
[846040014, 846040015, 846040016, 1, 846040021, 846040022, 846040013]
|
|
);
|
|
assert.strictEqual(
|
|
result.find((stage) => stage.stageId === 846040021).status,
|
|
"in-progress"
|
|
);
|
|
});
|
|
|
|
test("Specialist-process-sensitive ROW mapping remains unchanged for representative process IDs", () => {
|
|
const writtenReps = normalizeForAssertion(
|
|
getStagesForAppealType(846040015, 846040032, 846040000)
|
|
);
|
|
const hearing = normalizeForAssertion(
|
|
getStagesForAppealType(846040015, 846040032, 846040001)
|
|
);
|
|
|
|
assert.deepStrictEqual(writtenReps, hearing);
|
|
assert.deepStrictEqual(
|
|
writtenReps.map((stage) => stage.stageId),
|
|
[
|
|
846040033, 846040034, 846040035, 846040036, 846040062, 846040055,
|
|
846040037, 846040022, 846040013
|
|
]
|
|
);
|
|
assert.ok(
|
|
writtenReps.every((stage) => stage.status === "not-started"),
|
|
"Expected representative ROW input to preserve current all-not-started behaviour"
|
|
);
|
|
});
|
|
|
|
test("Closed-case fallback behaviour remains unchanged for all recognised closed statuses", () => {
|
|
const closedStatuses = [1000, 5, 6, 846040013, 846040060, 846040059];
|
|
|
|
for (const closedStatus of closedStatuses) {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040000, closedStatus)
|
|
);
|
|
|
|
const closedStage = result.find(
|
|
(stage) => stage.titleKey === "case-closed"
|
|
);
|
|
assert.ok(
|
|
closedStage,
|
|
`Expected case-closed stage for status ${closedStatus}`
|
|
);
|
|
assert.strictEqual(
|
|
closedStage.status,
|
|
"in-progress",
|
|
`Expected case-closed to be in-progress for status ${closedStatus}`
|
|
);
|
|
assert.strictEqual(result[0].status, "complete");
|
|
}
|
|
});
|
|
|
|
test("Unknown stage/status behaviour remains unchanged", () => {
|
|
const result = normalizeForAssertion(
|
|
getStagesForAppealType(846040000, 999999999)
|
|
);
|
|
|
|
assert.ok(result.every((stage) => stage.status === "not-started"));
|
|
});
|
|
|
|
test("Alias behaviour remains unchanged for representative aliases", () => {
|
|
const planningAlias = normalizeForAssertion(
|
|
getStagesForAppealType("PLANNING_S78", 846040018)
|
|
);
|
|
const planningCanonical = normalizeForAssertion(
|
|
getStagesForAppealType("S78", 846040018)
|
|
);
|
|
const callInAlias = normalizeForAssertion(
|
|
getStagesForAppealType("CALL_IN", 846040049)
|
|
);
|
|
const callInCanonical = normalizeForAssertion(
|
|
getStagesForAppealType("CALL_INS", 846040049)
|
|
);
|
|
|
|
assert.deepStrictEqual(planningAlias, planningCanonical);
|
|
assert.deepStrictEqual(callInAlias, callInCanonical);
|
|
});
|
|
|
|
test("Wrapper parity matches existing helper for representative inputs", () => {
|
|
const scenarios = [
|
|
[846040000, 846040014, undefined],
|
|
[846040000, 846040018, undefined],
|
|
[846040011, 846040006, undefined],
|
|
[846040004, 846040021, undefined],
|
|
[846040015, 846040032, 846040000],
|
|
[846040015, 846040032, 846040001],
|
|
[846040000, 846040013, undefined],
|
|
[846040000, 999999999, undefined]
|
|
];
|
|
|
|
for (const [caseType, currentStageId, specialistProcess] of scenarios) {
|
|
assert.deepStrictEqual(
|
|
normalizeForAssertion(
|
|
getLifecycleStagesForCase(
|
|
caseType,
|
|
currentStageId,
|
|
specialistProcess
|
|
)
|
|
),
|
|
normalizeForAssertion(
|
|
getStagesForAppealType(
|
|
caseType,
|
|
currentStageId,
|
|
specialistProcess
|
|
)
|
|
)
|
|
);
|
|
}
|
|
});
|
|
|
|
test("Wrapper preserves returned object shape for status consumer", () => {
|
|
const result = normalizeForAssertion(
|
|
getLifecycleStagesForCase(846040000, 846040014)
|
|
);
|
|
|
|
assert.ok(result.length > 0);
|
|
assert.ok(Object.prototype.hasOwnProperty.call(result[0], "id"));
|
|
assert.ok(Object.prototype.hasOwnProperty.call(result[0], "stageId"));
|
|
assert.ok(Object.prototype.hasOwnProperty.call(result[0], "titleKey"));
|
|
assert.ok(
|
|
Object.prototype.hasOwnProperty.call(result[0], "descriptionKey")
|
|
);
|
|
assert.ok(Object.prototype.hasOwnProperty.call(result[0], "status"));
|
|
});
|
|
|
|
const run = async () => {
|
|
let passed = 0;
|
|
|
|
for (const currentTest of tests) {
|
|
await currentTest.fn();
|
|
passed += 1;
|
|
}
|
|
|
|
console.log(
|
|
`Phase 22 case-lifecycle-stage-wrapper tests passed (${passed}/${tests.length}).`
|
|
);
|
|
};
|
|
|
|
module.exports = run;
|
|
|
|
if (require.main === module) {
|
|
run().catch((error) => {
|
|
console.error(error);
|
|
process.exit(1);
|
|
});
|
|
}
|