456 行
14 KiB
JavaScript
456 行
14 KiB
JavaScript
const workflowUtils = require("../../../src/utils/workflow");
|
|
|
|
const { resolveActionableStep } = workflowUtils;
|
|
|
|
const OWNER_ID = "11111111-1111-4111-8111-111111111111";
|
|
const MANAGER_ID = "22222222-2222-4222-8222-222222222222";
|
|
const FINANCE_MGR_ID = "33333333-3333-4333-8333-333333333333";
|
|
|
|
function buildSteps() {
|
|
return [
|
|
{
|
|
id: "approval_1_manager",
|
|
name: "主管审批",
|
|
type: "approval",
|
|
assignee_rule: { type: "department_manager" },
|
|
},
|
|
{
|
|
id: "approval_2_finance",
|
|
name: "财务复核",
|
|
type: "approval",
|
|
assignee_rule: { type: "role", value: "finance" },
|
|
},
|
|
];
|
|
}
|
|
|
|
function buildTx({
|
|
ownerRoles = ["ceo"],
|
|
managerId = null,
|
|
fallbackHasHolder = true,
|
|
} = {}) {
|
|
return {
|
|
employee: {
|
|
findUnique: vi.fn(async ({ where }) => {
|
|
if (where.id === OWNER_ID) {
|
|
return {
|
|
id: OWNER_ID,
|
|
direct_manager_id: managerId,
|
|
roles: ownerRoles.map((role_code) => ({ role_code })),
|
|
};
|
|
}
|
|
|
|
if (where.id === MANAGER_ID) {
|
|
return {
|
|
id: MANAGER_ID,
|
|
direct_manager_id: null,
|
|
roles: [{ role_code: "manager" }],
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}),
|
|
},
|
|
employeeRole: {
|
|
findFirst: vi.fn(async () => (
|
|
fallbackHasHolder ? { employee_id: FINANCE_MGR_ID } : null
|
|
)),
|
|
},
|
|
};
|
|
}
|
|
|
|
describe("workflow assignee resolution", () => {
|
|
describe("parseWorkflowSteps", () => {
|
|
it("throws error for invalid steps array", () => {
|
|
expect(() => workflowUtils.parseWorkflowSteps({})).toThrow(/参数校验失败/);
|
|
expect(() => workflowUtils.parseWorkflowSteps({ steps: [] })).toThrow(/参数校验失败/);
|
|
});
|
|
|
|
it("parses valid steps array", () => {
|
|
expect(workflowUtils.parseWorkflowSteps({ steps: [{ id: 1 }] })).toEqual([{ id: 1 }]);
|
|
});
|
|
});
|
|
|
|
describe("buildWorkflowStepsFromApprovalRule", () => {
|
|
it("builds steps correctly for valid rule", () => {
|
|
const result = workflowUtils.buildWorkflowStepsFromApprovalRule({
|
|
level1_role: "manager",
|
|
level2_role: "finance",
|
|
});
|
|
|
|
expect(result.length).toBe(2);
|
|
expect(result[0].assignee_rule.type).toBe("department_manager");
|
|
expect(result[1].assignee_rule.type).toBe("role");
|
|
expect(result[1].assignee_rule.value).toBe("finance");
|
|
});
|
|
|
|
it("throws if rule is empty or missing roles", () => {
|
|
expect(() => workflowUtils.buildWorkflowStepsFromApprovalRule({})).toThrow(/参数校验失败/);
|
|
});
|
|
|
|
it.each(["admin", "system_admin"])(
|
|
"rejects protected system role %s in approval rules",
|
|
(roleCode) => {
|
|
expect(() => workflowUtils.buildWorkflowStepsFromApprovalRule({ level1_role: roleCode }))
|
|
.toThrow(/参数校验失败/);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("getWorkflowStepsSnapshot", () => {
|
|
it.each(["admin", "system_admin"])(
|
|
"rejects protected system role %s in historical snapshots",
|
|
(roleCode) => {
|
|
expect(() => workflowUtils.getWorkflowStepsSnapshot({
|
|
context_data: {
|
|
workflow_steps_snapshot: [
|
|
{
|
|
id: `approval_1_${roleCode}`,
|
|
assignee_rule: { type: "role", value: roleCode },
|
|
},
|
|
],
|
|
},
|
|
})).toThrow(/参数校验失败/);
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("resolveWorkflowStepDisplayName", () => {
|
|
it("hides the internal role code in legacy owner fallback tasks", () => {
|
|
expect(workflowUtils.resolveWorkflowStepDisplayName({
|
|
step_name: "负责人本人申请兜底：finance",
|
|
assignee_role: "finance",
|
|
})).toBe("财务复核");
|
|
});
|
|
|
|
it("keeps normal readable workflow names unchanged", () => {
|
|
expect(workflowUtils.resolveWorkflowStepDisplayName({
|
|
step_name: "高额财务终审",
|
|
assignee_role: "finance",
|
|
})).toBe("高额财务终审");
|
|
});
|
|
});
|
|
|
|
describe("buildApprovalWorkflowSnapshot", () => {
|
|
it.each([
|
|
["small", "finance", null],
|
|
["large", "ceo", "finance"],
|
|
])("uses exactly one CEO step for finance-owned reimbursement %s", async (_name, level2, level3) => {
|
|
const tx = buildTx({ ownerRoles: ["finance", "employee"], managerId: MANAGER_ID });
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx, entityType: "reimbursement", ownerId: OWNER_ID, submitterId: MANAGER_ID,
|
|
approvalRule: { level1_role: "manager", level2_role: level2, level3_role: level3 },
|
|
});
|
|
expect(steps).toEqual([{
|
|
id: "approval_1_ceo_finance_owner", name: "总经理审批", type: "approval",
|
|
assignee_rule: { type: "role", value: "ceo" },
|
|
}]);
|
|
expect(tx.employeeRole.findFirst).toHaveBeenCalledWith({
|
|
where: {
|
|
role_code: "ceo",
|
|
employee_id: { notIn: [OWNER_ID, MANAGER_ID] },
|
|
employee: { status: "active", archived_at: null },
|
|
},
|
|
select: { employee_id: true },
|
|
});
|
|
});
|
|
|
|
it.each([["finance"], ["finance", "ceo"]])("blocks finance owner roles %j without non-applicant CEO", async (...ownerRoles) => {
|
|
const tx = buildTx({ ownerRoles, fallbackHasHolder: false });
|
|
await expect(workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx, entityType: "reimbursement", ownerId: OWNER_ID, submitterId: OWNER_ID,
|
|
approvalRule: { level1_role: "finance" },
|
|
})).rejects.toMatchObject({
|
|
statusCode: 409,
|
|
details: { workflow: "no_actionable_approver", reason: "finance_owner_ceo_unavailable" },
|
|
});
|
|
});
|
|
|
|
it("does not simplify other entities or a finance submitter's employee-owned form", async () => {
|
|
for (const [entityType, ownerRoles] of [["purchase_request", ["finance"]], ["reimbursement", ["employee"]]]) {
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx: buildTx({ ownerRoles }), entityType, ownerId: OWNER_ID, submitterId: FINANCE_MGR_ID,
|
|
approvalRule: { level1_role: "manager", level2_role: "ceo", level3_role: "finance" },
|
|
});
|
|
expect(steps).toHaveLength(3);
|
|
}
|
|
});
|
|
|
|
it("keeps ordinary employee approval snapshots unchanged", async () => {
|
|
const tx = buildTx({ ownerRoles: ["employee"], managerId: MANAGER_ID });
|
|
|
|
const result = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
level2_role: "finance",
|
|
owner_self_fallback_role: "finance_mgr",
|
|
},
|
|
});
|
|
|
|
expect(result.map((step) => step.assignee_rule)).toEqual([
|
|
{ type: "department_manager" },
|
|
{ type: "role", value: "finance" },
|
|
]);
|
|
expect(tx.employeeRole.findFirst).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("uses finance_mgr as non-self fallback for CEO owner applications", async () => {
|
|
const tx = buildTx({ ownerRoles: ["ceo"], managerId: null });
|
|
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
level2_role: "finance",
|
|
owner_self_fallback_role: "finance_mgr",
|
|
},
|
|
});
|
|
|
|
expect(steps.map((step) => step.assignee_rule)).toEqual([
|
|
{ type: "role", value: "finance_mgr" },
|
|
{ type: "role", value: "finance" },
|
|
]);
|
|
expect(steps[0].id).toContain("owner_self_fallback");
|
|
expect(steps[0].name).toBe("财务复核");
|
|
|
|
const resolved = await resolveActionableStep({
|
|
tx,
|
|
steps,
|
|
startIndex: 0,
|
|
ownerId: OWNER_ID,
|
|
blockOnUnresolvedAssignee: true,
|
|
});
|
|
expect(resolved.actionable.assigneeRole).toBe("finance_mgr");
|
|
});
|
|
|
|
it.each([
|
|
["small", { level1_role: "manager", level2_role: "finance", level3_role: null }],
|
|
["medium", { level1_role: "manager", level2_role: "finance", level3_role: null }],
|
|
["large", { level1_role: "manager", level2_role: "ceo", level3_role: "finance" }],
|
|
])("uses one finance fallback node for CEO owner %s rules", async (_name, rule) => {
|
|
const tx = buildTx({ ownerRoles: ["ceo"], managerId: null });
|
|
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
...rule,
|
|
owner_self_fallback_role: "finance",
|
|
},
|
|
});
|
|
|
|
expect(steps.map((step) => step.assignee_rule)).toEqual([
|
|
{ type: "role", value: "finance" },
|
|
]);
|
|
expect(steps[0].id).toContain("owner_self_fallback");
|
|
expect(steps[0].name).toBe("财务复核");
|
|
});
|
|
|
|
it("removes CEO self node and duplicate fallback role for large CEO owner applications", async () => {
|
|
const tx = buildTx({ ownerRoles: ["ceo"], managerId: null });
|
|
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
level2_role: "ceo",
|
|
level3_role: "finance_mgr",
|
|
owner_self_fallback_role: "finance_mgr",
|
|
},
|
|
});
|
|
|
|
expect(steps.map((step) => step.assignee_rule)).toEqual([
|
|
{ type: "role", value: "finance_mgr" },
|
|
]);
|
|
});
|
|
|
|
it("keeps missing-manager blocking behavior when no owner fallback is configured", async () => {
|
|
const tx = buildTx({ ownerRoles: ["ceo"], managerId: null });
|
|
|
|
const steps = await workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
level2_role: "finance",
|
|
owner_self_fallback_role: null,
|
|
},
|
|
});
|
|
|
|
await expect(
|
|
resolveActionableStep({
|
|
tx,
|
|
steps,
|
|
startIndex: 0,
|
|
ownerId: OWNER_ID,
|
|
blockOnUnresolvedAssignee: true,
|
|
}),
|
|
).rejects.toMatchObject({
|
|
details: {
|
|
workflow: "no_actionable_approver",
|
|
reason: "no_manager_found",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("blocks fallback when no active non-self holder exists", async () => {
|
|
const tx = buildTx({
|
|
ownerRoles: ["ceo"],
|
|
managerId: null,
|
|
fallbackHasHolder: false,
|
|
});
|
|
|
|
await expect(
|
|
workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
owner_self_fallback_role: "finance",
|
|
},
|
|
}),
|
|
).rejects.toMatchObject({
|
|
details: {
|
|
workflow: "no_actionable_approver",
|
|
reason: "owner_self_fallback_role_unavailable",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("blocks fallback when the owner also holds the fallback role", async () => {
|
|
const tx = buildTx({
|
|
ownerRoles: ["ceo", "finance"],
|
|
managerId: null,
|
|
});
|
|
|
|
await expect(
|
|
workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
owner_self_fallback_role: "finance",
|
|
},
|
|
}),
|
|
).rejects.toMatchObject({
|
|
details: {
|
|
workflow: "no_actionable_approver",
|
|
reason: "owner_self_fallback_self_role",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("blocks unsupported owner self fallback roles before creating a task", async () => {
|
|
const tx = buildTx({ ownerRoles: ["ceo"], managerId: null });
|
|
|
|
await expect(
|
|
workflowUtils.buildApprovalWorkflowSnapshot({
|
|
tx,
|
|
ownerId: OWNER_ID,
|
|
approvalRule: {
|
|
level1_role: "manager",
|
|
owner_self_fallback_role: "hr",
|
|
},
|
|
}),
|
|
).rejects.toMatchObject({
|
|
details: {
|
|
ownerSelfFallbackRole: "unsupported_business_approval_role",
|
|
},
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("resolveAssigneeFromRule", () => {
|
|
it("resolves role type", async () => {
|
|
const result = await workflowUtils.resolveAssigneeFromRule({ type: "role", value: "hr" });
|
|
|
|
expect(result.assigneeRole).toBe("hr");
|
|
expect(result.assigneeId).toBe(null);
|
|
});
|
|
|
|
it("throws for invalid rule", async () => {
|
|
await expect(workflowUtils.resolveAssigneeFromRule(null)).rejects.toThrow(/参数校验失败/);
|
|
await expect(workflowUtils.resolveAssigneeFromRule({ type: "unknown" })).rejects.toThrow(/参数校验失败/);
|
|
});
|
|
|
|
it.each(["admin", "system_admin"])(
|
|
"rejects protected system role %s during runtime resolution",
|
|
async (roleCode) => {
|
|
await expect(
|
|
workflowUtils.resolveAssigneeFromRule({ type: "role", value: roleCode }),
|
|
).rejects.toMatchObject({
|
|
details: { workflow: "unsupported_business_approval_role" },
|
|
});
|
|
},
|
|
);
|
|
});
|
|
|
|
describe("toMoneyString", () => {
|
|
it("converts values to string correctly", () => {
|
|
expect(workflowUtils.toMoneyString(null)).toBe(null);
|
|
expect(workflowUtils.toMoneyString("10.0")).toBe("10.0");
|
|
expect(workflowUtils.toMoneyString(10)).toBe("10");
|
|
});
|
|
});
|
|
|
|
it("blocks submit-time workflow resolution when the direct manager is missing", async () => {
|
|
const tx = {
|
|
employee: {
|
|
findUnique: vi.fn(async () => ({
|
|
id: OWNER_ID,
|
|
direct_manager_id: null,
|
|
})),
|
|
},
|
|
};
|
|
|
|
await expect(
|
|
resolveActionableStep({
|
|
tx,
|
|
steps: buildSteps(),
|
|
startIndex: 0,
|
|
ownerId: OWNER_ID,
|
|
blockOnUnresolvedAssignee: true,
|
|
}),
|
|
).rejects.toMatchObject({
|
|
details: {
|
|
workflow: "no_actionable_approver",
|
|
reason: "no_manager_found",
|
|
stepId: "approval_1_manager",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("keeps legacy skip behavior when strict submit resolution is not requested", async () => {
|
|
const tx = {
|
|
employee: {
|
|
findUnique: vi.fn(async () => ({
|
|
id: OWNER_ID,
|
|
direct_manager_id: null,
|
|
})),
|
|
},
|
|
};
|
|
|
|
const result = await resolveActionableStep({
|
|
tx,
|
|
steps: buildSteps(),
|
|
startIndex: 0,
|
|
ownerId: OWNER_ID,
|
|
});
|
|
|
|
expect(result.actionable).toEqual(
|
|
expect.objectContaining({
|
|
step: expect.objectContaining({ id: "approval_2_finance" }),
|
|
assigneeRole: "finance",
|
|
}),
|
|
);
|
|
expect(result.skipped).toEqual([
|
|
expect.objectContaining({
|
|
reason: "no_manager_found",
|
|
}),
|
|
]);
|
|
});
|
|
});
|