wangsli
1f8d5b658a
汇总已落盘的借款本金与还款、兼容历史编号的周期化编号、付款责任与回单核验、报销进度和排序、PWA/采购事务、错误原因与日期校验及ERP退役。 统一共享预算池锁序和锁后判断，恢复差旅原预算选择，补原因码固定夹具及反向完整性检查。 纳入配套迁移、测试、受管QA、分层验收合同、规约及任务记录；原始证据留在ignored artifacts。 关联任务：09-17-company-loan-principal-repayment、09-17-erp-exclusive-retirement、09-18-reimbursement-periodic-numbering、09-08-reimbursement-payment-closeout、09-18-local-concurrency-product-fixes、09-19-budget-pool-concurrency、09-05-error-explainability-payment-readiness。 预算补审由Claude定向验证2文件928项通过，原4446/28及r6结果仍仅对应各自历史输入；本轮未重跑测试。 完整新候选门禁、R1真实入口接入与12项公网义务仍开放。生产编号未启用、差旅仍冻结；不推送、不部署，不宣称发布资格。
673 行
32 KiB
JavaScript
673 行
32 KiB
JavaScript
const { enableNumbering } = require("../helpers/activeNumbering");
|
|
const Fastify = require("fastify");
|
|
|
|
const { AppError } = require("../../../src/utils/AppError");
|
|
const projectsRoutes = require("../../../src/routes/projects");
|
|
|
|
const PROJECT_ID = "11111111-1111-4111-8111-111111111111";
|
|
const OWNER_ID = "22222222-2222-4222-8222-222222222222";
|
|
const MANAGER_ID = "33333333-3333-4333-8333-333333333333";
|
|
const MEMBER_ID = "44444444-4444-4444-8444-444444444444";
|
|
const OUTSIDER_ID = "55555555-5555-4555-8555-555555555555";
|
|
const NOW = new Date("2026-03-22T09:30:00.000Z");
|
|
|
|
function buildFeatureFlagRecord(flagKey) {
|
|
return {
|
|
id: `flag-${flagKey}`,
|
|
flag_key: flagKey,
|
|
override_mode: "force_on",
|
|
rollout_type: "global",
|
|
department_ids: [],
|
|
note: "unit-test",
|
|
version: 1,
|
|
created_at: NOW,
|
|
created_by: null,
|
|
updated_at: NOW,
|
|
updated_by: null,
|
|
};
|
|
}
|
|
|
|
function buildEmployee(id, name, employeeNo) {
|
|
return { id, name, employee_no: employeeNo };
|
|
}
|
|
|
|
function buildProjectState(overrides = {}) {
|
|
return {
|
|
id: PROJECT_ID,
|
|
project_no: "PRJ-001",
|
|
name: "试点项目",
|
|
client_name: "测试客户",
|
|
client_alias: "测试客户简称",
|
|
owner_employee_id: OWNER_ID,
|
|
manager_employee_id: MANAGER_ID,
|
|
status: "active",
|
|
starts_at: new Date("2026-03-01T00:00:00.000Z"),
|
|
target_end_at: new Date("2026-03-31T00:00:00.000Z"),
|
|
actual_end_at: null,
|
|
summary: "用于 R23 单测的项目",
|
|
is_confidential: false,
|
|
created_at: NOW,
|
|
updated_at: NOW,
|
|
owner: buildEmployee(OWNER_ID, "Owner", "E001"),
|
|
manager: buildEmployee(MANAGER_ID, "Manager", "E002"),
|
|
members: [
|
|
{
|
|
id: "aaaaaaa1-1111-4111-8111-111111111111",
|
|
employee_id: MEMBER_ID,
|
|
role: "member",
|
|
joined_at: NOW,
|
|
left_at: null,
|
|
employee: buildEmployee(MEMBER_ID, "Member", "E003"),
|
|
},
|
|
],
|
|
milestones: [],
|
|
tasks: [],
|
|
risks: [],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createPrismaState({ communicationLogs = [], closureChecklistItems = [], purchaseRequests = [] } = {}) {
|
|
const state = {
|
|
project: buildProjectState(),
|
|
communicationLogs: communicationLogs.map((item) => ({ ...item })),
|
|
closureChecklistItems: closureChecklistItems.map((item) => ({ ...item })),
|
|
purchaseRequests: purchaseRequests.map((item) => ({ ...item })),
|
|
openRiskCount: 0,
|
|
openReimbursementCount: 0,
|
|
openTravelCount: 0,
|
|
deliveryRecordCount: 0,
|
|
contractCount: 0,
|
|
confidentialDocRefCount: 0,
|
|
auditEntries: [],
|
|
};
|
|
|
|
function withProjectCounts(project) {
|
|
return {
|
|
...project,
|
|
_count: {
|
|
members: (project.members ?? []).length,
|
|
milestones: (project.milestones ?? []).length,
|
|
tasks: (project.tasks ?? []).length,
|
|
risks: (project.risks ?? []).length,
|
|
reimbursements: 0,
|
|
purchase_requests: state.purchaseRequests.filter((item) => item.project_id === project.id).length,
|
|
travel_requests: 0,
|
|
todo_items: 0,
|
|
weekly_reports: 0,
|
|
communication_logs: state.communicationLogs.length,
|
|
closure_checklist_items: state.closureChecklistItems.length,
|
|
contracts: state.contractCount,
|
|
deliveries: state.deliveryRecordCount,
|
|
document_refs: state.confidentialDocRefCount,
|
|
},
|
|
};
|
|
}
|
|
|
|
function nextUuid(seed) {
|
|
return `99999999-9999-4999-8999-${String(seed).padStart(12, "0")}`;
|
|
}
|
|
|
|
function attachChecklistCompleter(item) {
|
|
return {
|
|
...item,
|
|
completer: item.completed_by ? buildEmployee(item.completed_by, item.completed_by === OWNER_ID ? "Owner" : "Manager", "E999") : null,
|
|
};
|
|
}
|
|
|
|
function attachCommunicationCreator(item) {
|
|
const creators = {
|
|
[OWNER_ID]: buildEmployee(OWNER_ID, "Owner", "E001"),
|
|
[MANAGER_ID]: buildEmployee(MANAGER_ID, "Manager", "E002"),
|
|
[MEMBER_ID]: buildEmployee(MEMBER_ID, "Member", "E003"),
|
|
};
|
|
return {
|
|
...item,
|
|
creator: creators[item.created_by] ?? buildEmployee(item.created_by, "Unknown", "E000"),
|
|
};
|
|
}
|
|
|
|
const prisma = {
|
|
businessNumberPolicy: { findUnique: vi.fn(async () => null) },
|
|
$executeRaw: vi.fn(async () => 0),
|
|
featureFlag: {
|
|
findUnique: vi.fn().mockImplementation(async ({ where }) => buildFeatureFlagRecord(where.flag_key)),
|
|
},
|
|
project: {
|
|
findUnique: vi.fn().mockImplementation(async () => withProjectCounts(state.project)),
|
|
update: vi.fn().mockImplementation(async ({ data }) => {
|
|
state.project = {
|
|
...state.project,
|
|
...(data.name !== undefined ? { name: data.name } : {}),
|
|
...(data.client_name !== undefined ? { client_name: data.client_name } : {}),
|
|
...(data.client_alias !== undefined ? { client_alias: data.client_alias } : {}),
|
|
...(data.owner_employee_id !== undefined ? { owner_employee_id: data.owner_employee_id } : {}),
|
|
...(data.manager_employee_id !== undefined ? { manager_employee_id: data.manager_employee_id } : {}),
|
|
...(data.status !== undefined ? { status: data.status } : {}),
|
|
...(data.starts_at !== undefined ? { starts_at: data.starts_at } : {}),
|
|
...(data.target_end_at !== undefined ? { target_end_at: data.target_end_at } : {}),
|
|
...(data.actual_end_at !== undefined ? { actual_end_at: data.actual_end_at } : {}),
|
|
...(data.summary !== undefined ? { summary: data.summary } : {}),
|
|
...(data.is_confidential !== undefined ? { is_confidential: data.is_confidential } : {}),
|
|
updated_at: NOW,
|
|
};
|
|
return withProjectCounts(state.project);
|
|
}),
|
|
},
|
|
projectCommunicationLog: {
|
|
count: vi.fn().mockImplementation(async ({ where }) => {
|
|
const items = state.communicationLogs.filter((item) => item.project_id === where.project_id);
|
|
if (!where.next_follow_up_date) {
|
|
return items.length;
|
|
}
|
|
return items.filter((item) => {
|
|
if (!item.next_follow_up_date) {
|
|
return false;
|
|
}
|
|
const next = new Date(item.next_follow_up_date).getTime();
|
|
if (where.next_follow_up_date.gte && where.next_follow_up_date.lte) {
|
|
return next >= new Date(where.next_follow_up_date.gte).getTime() && next <= new Date(where.next_follow_up_date.lte).getTime();
|
|
}
|
|
if (where.next_follow_up_date.lt) {
|
|
return next < new Date(where.next_follow_up_date.lt).getTime();
|
|
}
|
|
return false;
|
|
}).length;
|
|
}),
|
|
findFirst: vi.fn().mockImplementation(async ({ where }) => {
|
|
const items = state.communicationLogs
|
|
.filter((item) => item.project_id === where.project_id)
|
|
.sort((left, right) => new Date(right.happened_at).getTime() - new Date(left.happened_at).getTime());
|
|
return items[0] ? attachCommunicationCreator(items[0]) : null;
|
|
}),
|
|
findMany: vi.fn().mockImplementation(async ({ where }) => {
|
|
return state.communicationLogs
|
|
.filter((item) => item.project_id === where.project_id)
|
|
.sort((left, right) => new Date(right.happened_at).getTime() - new Date(left.happened_at).getTime())
|
|
.map((item) => attachCommunicationCreator(item));
|
|
}),
|
|
create: vi.fn().mockImplementation(async ({ data }) => {
|
|
const created = {
|
|
id: nextUuid(state.communicationLogs.length + 1),
|
|
project_id: data.project_id,
|
|
happened_at: data.happened_at,
|
|
channel: data.channel,
|
|
external_contact_name: data.external_contact_name,
|
|
external_org_name: data.external_org_name,
|
|
summary: data.summary,
|
|
next_action: data.next_action,
|
|
next_follow_up_date: data.next_follow_up_date,
|
|
created_by: data.created_by,
|
|
created_at: NOW,
|
|
updated_at: NOW,
|
|
};
|
|
state.communicationLogs.unshift(created);
|
|
return attachCommunicationCreator(created);
|
|
}),
|
|
findUnique: vi.fn().mockImplementation(async ({ where }) => {
|
|
const item = state.communicationLogs.find((entry) => entry.id === where.id);
|
|
return item ? attachCommunicationCreator(item) : null;
|
|
}),
|
|
update: vi.fn().mockImplementation(async ({ where, data }) => {
|
|
const index = state.communicationLogs.findIndex((entry) => entry.id === where.id);
|
|
if (index < 0) {
|
|
return null;
|
|
}
|
|
state.communicationLogs[index] = {
|
|
...state.communicationLogs[index],
|
|
...(data.happened_at !== undefined ? { happened_at: data.happened_at } : {}),
|
|
...(data.channel !== undefined ? { channel: data.channel } : {}),
|
|
...(data.external_contact_name !== undefined ? { external_contact_name: data.external_contact_name } : {}),
|
|
...(data.external_org_name !== undefined ? { external_org_name: data.external_org_name } : {}),
|
|
...(data.summary !== undefined ? { summary: data.summary } : {}),
|
|
...(data.next_action !== undefined ? { next_action: data.next_action } : {}),
|
|
...(data.next_follow_up_date !== undefined ? { next_follow_up_date: data.next_follow_up_date } : {}),
|
|
updated_at: NOW,
|
|
};
|
|
return attachCommunicationCreator(state.communicationLogs[index]);
|
|
}),
|
|
},
|
|
projectClosureChecklistItem: {
|
|
count: vi.fn().mockImplementation(async ({ where }) => state.closureChecklistItems.filter((item) => item.project_id === where.project_id).length),
|
|
createMany: vi.fn().mockImplementation(async ({ data }) => {
|
|
data.forEach((item, index) => {
|
|
if (state.closureChecklistItems.some((current) => current.project_id === item.project_id && current.item_key === item.item_key)) {
|
|
return;
|
|
}
|
|
state.closureChecklistItems.push({
|
|
id: nextUuid(100 + state.closureChecklistItems.length + index),
|
|
project_id: item.project_id,
|
|
item_key: item.item_key,
|
|
title: item.title,
|
|
status: item.status,
|
|
note: null,
|
|
sort_order: item.sort_order,
|
|
completed_at: null,
|
|
completed_by: null,
|
|
created_at: NOW,
|
|
updated_at: NOW,
|
|
});
|
|
});
|
|
return { count: data.length };
|
|
}),
|
|
findMany: vi.fn().mockImplementation(async ({ where, select }) => {
|
|
const items = state.closureChecklistItems
|
|
.filter((item) => item.project_id === where.project_id)
|
|
.sort((left, right) => left.sort_order - right.sort_order);
|
|
if (select?.status) {
|
|
return items.map((item) => ({ status: item.status }));
|
|
}
|
|
return items.map((item) => attachChecklistCompleter(item));
|
|
}),
|
|
findUnique: vi.fn().mockImplementation(async ({ where }) => {
|
|
const item = state.closureChecklistItems.find((entry) => entry.id === where.id);
|
|
return item ? attachChecklistCompleter(item) : null;
|
|
}),
|
|
update: vi.fn().mockImplementation(async ({ where, data }) => {
|
|
const index = state.closureChecklistItems.findIndex((entry) => entry.id === where.id);
|
|
if (index < 0) {
|
|
return null;
|
|
}
|
|
state.closureChecklistItems[index] = {
|
|
...state.closureChecklistItems[index],
|
|
...(data.status !== undefined ? { status: data.status } : {}),
|
|
...(data.note !== undefined ? { note: data.note } : {}),
|
|
...(data.completed_at !== undefined ? { completed_at: data.completed_at } : {}),
|
|
...(data.completed_by !== undefined ? { completed_by: data.completed_by } : {}),
|
|
updated_at: NOW,
|
|
};
|
|
return attachChecklistCompleter(state.closureChecklistItems[index]);
|
|
}),
|
|
},
|
|
projectRisk: { count: vi.fn().mockImplementation(async () => state.openRiskCount) },
|
|
reimbursementForm: { count: vi.fn().mockImplementation(async () => state.openReimbursementCount) },
|
|
travelRequest: { count: vi.fn().mockImplementation(async () => state.openTravelCount) },
|
|
purchaseRequest: {
|
|
findMany: vi.fn().mockImplementation(async ({ where }) => {
|
|
return state.purchaseRequests
|
|
.filter((item) => item.project_id === where.project_id)
|
|
.sort((left, right) => new Date(right.updated_at).getTime() - new Date(left.updated_at).getTime());
|
|
}),
|
|
},
|
|
projectDeliveryRecord: { count: vi.fn().mockImplementation(async () => state.deliveryRecordCount) },
|
|
contractRegistry: { count: vi.fn().mockImplementation(async () => state.contractCount) },
|
|
confidentialDocumentRef: { count: vi.fn().mockImplementation(async () => state.confidentialDocRefCount) },
|
|
auditLog: {
|
|
create: vi.fn().mockImplementation(async ({ data }) => {
|
|
state.auditEntries.push(data);
|
|
return { id: nextUuid(500 + state.auditEntries.length) };
|
|
}),
|
|
},
|
|
};
|
|
|
|
prisma.$transaction = vi.fn(async (cb) => cb(prisma));
|
|
return { state, prisma };
|
|
}
|
|
|
|
async function buildApp({ employee, prisma }) {
|
|
const app = Fastify();
|
|
|
|
app.decorate("prisma", prisma);
|
|
app.decorate("config", {
|
|
projectDomainEnabled: true,
|
|
projectLinkingEnabled: true,
|
|
projectCommunicationLogEnabled: true,
|
|
projectClosureChecklistEnabled: true,
|
|
confidentialDocRefsEnabled: true,
|
|
});
|
|
app.decorate("authenticate", async (request) => {
|
|
if (!request.headers.authorization) {
|
|
throw new AppError({ code: "AUTH_001", message: "未登录", statusCode: 401 });
|
|
}
|
|
request.employee = employee;
|
|
});
|
|
app.decorate("hasPermission", (actor, permissionCode) => {
|
|
return (actor?.permissionCodes ?? []).includes("*") || (actor?.permissionCodes ?? []).includes(permissionCode);
|
|
});
|
|
app.setErrorHandler((error, request, reply) => {
|
|
if (error instanceof AppError) {
|
|
return reply.status(error.statusCode).send({
|
|
requestId: request.id,
|
|
error: { code: error.code, message: error.message, details: error.details ?? {} },
|
|
});
|
|
}
|
|
return reply.status(500).send({
|
|
requestId: request.id,
|
|
error: { code: "SYS_001", message: "服务器内部错误", details: {} },
|
|
});
|
|
});
|
|
|
|
await app.register(projectsRoutes, { prefix: "/api" });
|
|
return app;
|
|
}
|
|
|
|
describe("project R23 routes", () => {
|
|
it("returns purchase request summary only to readable project users", async () => {
|
|
const { prisma } = createPrismaState({
|
|
purchaseRequests: [
|
|
{
|
|
id: "77777777-7777-4777-8777-777777777777",
|
|
project_id: PROJECT_ID,
|
|
request_no: "PR-20260513-001",
|
|
title: "测试设备采购",
|
|
status: "approved",
|
|
total_amount: "1200.50",
|
|
updated_at: new Date("2026-05-13T08:00:00.000Z"),
|
|
},
|
|
{
|
|
id: "88888888-8888-4888-8888-888888888888",
|
|
project_id: PROJECT_ID,
|
|
request_no: null,
|
|
title: "未编号采购草稿",
|
|
status: "draft",
|
|
total_amount: "99.50",
|
|
updated_at: new Date("2026-05-13T09:00:00.000Z"),
|
|
},
|
|
],
|
|
});
|
|
const memberApp = await buildApp({
|
|
employee: { id: MEMBER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
|
|
const response = await memberApp.inject({
|
|
method: "GET",
|
|
url: `/api/projects/${PROJECT_ID}/purchase-requests/summary`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
});
|
|
|
|
expect(response.statusCode).toBe(200);
|
|
expect(response.json().data).toEqual({
|
|
totalAmount: "1300.00",
|
|
items: [
|
|
{
|
|
id: "88888888-8888-4888-8888-888888888888",
|
|
requestNo: "88888888-8888-4888-8888-888888888888",
|
|
title: "未编号采购草稿",
|
|
status: "draft",
|
|
totalAmount: "99.50",
|
|
updatedAt: "2026-05-13T09:00:00.000Z",
|
|
},
|
|
{
|
|
id: "77777777-7777-4777-8777-777777777777",
|
|
requestNo: "PR-20260513-001",
|
|
title: "测试设备采购",
|
|
status: "approved",
|
|
totalAmount: "1200.50",
|
|
updatedAt: "2026-05-13T08:00:00.000Z",
|
|
},
|
|
],
|
|
});
|
|
|
|
const outsiderApp = await buildApp({
|
|
employee: { id: OUTSIDER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
const forbiddenResponse = await outsiderApp.inject({
|
|
method: "GET",
|
|
url: `/api/projects/${PROJECT_ID}/purchase-requests/summary`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
});
|
|
|
|
expect(forbiddenResponse.statusCode).toBe(403);
|
|
expect(forbiddenResponse.json().error.code).toBe("PERM_001");
|
|
|
|
await Promise.all([memberApp.close(), outsiderApp.close()]);
|
|
});
|
|
|
|
it("allows project member to create communication logs and blocks outsiders", async () => {
|
|
const { prisma } = createPrismaState();
|
|
const memberApp = await buildApp({
|
|
employee: { id: MEMBER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
|
|
const createResponse = await memberApp.inject({
|
|
method: "POST",
|
|
url: `/api/projects/${PROJECT_ID}/communication-logs`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
payload: {
|
|
happenedAt: "2026-03-22T08:00:00.000Z",
|
|
channel: "wechat",
|
|
externalContactName: "王总",
|
|
externalOrgName: "测试客户",
|
|
summary: "客户确认下周一现场启动。",
|
|
nextAction: "准备启动材料",
|
|
nextFollowUpDate: "2026-03-24",
|
|
},
|
|
});
|
|
|
|
expect(createResponse.statusCode).toBe(201);
|
|
expect(createResponse.json().data.item).toEqual(
|
|
expect.objectContaining({
|
|
channel: "wechat",
|
|
summary: "客户确认下周一现场启动。",
|
|
canEdit: true,
|
|
}),
|
|
);
|
|
|
|
const outsiderApp = await buildApp({
|
|
employee: { id: OUTSIDER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
const outsiderResponse = await outsiderApp.inject({
|
|
method: "GET",
|
|
url: `/api/projects/${PROJECT_ID}/communication-logs`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
});
|
|
|
|
expect(outsiderResponse.statusCode).toBe(403);
|
|
expect(outsiderResponse.json().error.code).toBe("PERM_001");
|
|
|
|
await Promise.all([memberApp.close(), outsiderApp.close()]);
|
|
});
|
|
|
|
it("enforces 24h edit window for creators while allowing owners to edit anytime", async () => {
|
|
const { state, prisma } = createPrismaState({
|
|
communicationLogs: [
|
|
{
|
|
id: "66666666-6666-4666-8666-666666666666",
|
|
project_id: PROJECT_ID,
|
|
happened_at: new Date("2026-03-21T08:00:00.000Z"),
|
|
channel: "phone",
|
|
external_contact_name: "李总",
|
|
external_org_name: "测试客户",
|
|
summary: "客户电话确认测试安排。",
|
|
next_action: "同步排期",
|
|
next_follow_up_date: new Date("2026-03-23T00:00:00.000Z"),
|
|
created_by: MEMBER_ID,
|
|
created_at: new Date("2026-03-20T08:00:00.000Z"),
|
|
updated_at: new Date("2026-03-20T08:00:00.000Z"),
|
|
},
|
|
],
|
|
});
|
|
|
|
const staleCreatorApp = await buildApp({
|
|
employee: { id: MEMBER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
const staleResponse = await staleCreatorApp.inject({
|
|
method: "PATCH",
|
|
url: `/api/projects/${PROJECT_ID}/communication-logs/66666666-6666-4666-8666-666666666666`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
payload: { summary: "尝试修改过期记录" },
|
|
});
|
|
|
|
expect(staleResponse.statusCode).toBe(403);
|
|
|
|
const ownerApp = await buildApp({
|
|
employee: { id: OWNER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
const ownerResponse = await ownerApp.inject({
|
|
method: "PATCH",
|
|
url: `/api/projects/${PROJECT_ID}/communication-logs/66666666-6666-4666-8666-666666666666`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
payload: { summary: "Owner 已补充最新沟通结果" },
|
|
});
|
|
|
|
expect(ownerResponse.statusCode).toBe(200);
|
|
expect(ownerResponse.json().data.item.summary).toBe("Owner 已补充最新沟通结果");
|
|
expect(state.communicationLogs[0].summary).toBe("Owner 已补充最新沟通结果");
|
|
|
|
await Promise.all([staleCreatorApp.close(), ownerApp.close()]);
|
|
});
|
|
|
|
it("bootstraps closure checklist and requires note when waiving", async () => {
|
|
const { prisma } = createPrismaState();
|
|
const app = await buildApp({
|
|
employee: { id: OWNER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
|
|
const listResponse = await app.inject({
|
|
method: "GET",
|
|
url: `/api/projects/${PROJECT_ID}/closure-checklist`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
});
|
|
|
|
expect(listResponse.statusCode).toBe(200);
|
|
expect(listResponse.json().data.items).toHaveLength(6);
|
|
expect(prisma.projectClosureChecklistItem.createMany).toHaveBeenCalledTimes(1);
|
|
|
|
const firstItemId = listResponse.json().data.items[0].id;
|
|
const waiveResponse = await app.inject({
|
|
method: "PATCH",
|
|
url: `/api/projects/${PROJECT_ID}/closure-checklist/${firstItemId}`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
payload: { status: "waived", note: "" },
|
|
});
|
|
|
|
expect(waiveResponse.statusCode).toBe(400);
|
|
expect(waiveResponse.json().error.details).toEqual(expect.objectContaining({ note: "waived_requires_note" }));
|
|
|
|
await app.close();
|
|
});
|
|
|
|
it("returns closureWarning when project is completed with pending checklist items", async () => {
|
|
const { prisma } = createPrismaState();
|
|
const app = await buildApp({
|
|
employee: { id: OWNER_ID, department_id: null, permissionCodes: ["project.view_own"] },
|
|
prisma,
|
|
});
|
|
|
|
const response = await app.inject({
|
|
method: "PATCH",
|
|
url: `/api/projects/${PROJECT_ID}`,
|
|
headers: { authorization: "Bearer test-token" },
|
|
payload: { status: "completed" },
|
|
});
|
|
|
|
expect(response.statusCode).toBe(200);
|
|
expect(response.json().data.item.status).toBe("completed");
|
|
expect(response.json().data.closureWarning).toEqual(
|
|
expect.objectContaining({ pendingCount: 6 }),
|
|
);
|
|
|
|
await app.close();
|
|
});
|
|
});
|
|
|
|
const ERROR_CHILD_ID = "66666666-6666-4666-8666-666666666666";
|
|
const errorApps = [];
|
|
afterEach(async () => { await Promise.all(errorApps.splice(0).map((app) => app.close())); });
|
|
async function errorContext({ employee = { id: OWNER_ID, permissionCodes: ["project.manage"] }, emptyChecklist = false } = {}) {
|
|
const context = createPrismaState({
|
|
communicationLogs: [{ id: ERROR_CHILD_ID, project_id: PROJECT_ID, summary: "合成沟通", channel: "meeting", happened_at: NOW, created_at: NOW, created_by: OWNER_ID }],
|
|
closureChecklistItems: emptyChecklist ? [] : [{ id: ERROR_CHILD_ID, project_id: PROJECT_ID, status: "pending", title: "合成收口项", sort_order: 1, note: null }],
|
|
});
|
|
const { prisma, state } = context;
|
|
for (const model of ["projectMember", "projectMilestone", "projectTask", "projectRisk", "projectDeliveryRecord"]) {
|
|
prisma[model] ??= {};
|
|
for (const method of ["create", "update", "upsert"]) prisma[model][method] = vi.fn(async ({ data, create }) => ({ id: ERROR_CHILD_ID, project_id: PROJECT_ID, ...(data ?? create) }));
|
|
}
|
|
prisma.project.create = vi.fn(async ({ data }) => ({ ...state.project, project_no: data.project_no }));
|
|
prisma.project.findMany = vi.fn().mockResolvedValue([]);
|
|
const app = await buildApp({ employee, prisma }); errorApps.push(app);
|
|
return { ...context, app };
|
|
}
|
|
function errorRequest(method, suffix, payload) { return { method, url: `/api/projects${suffix}`, headers: { authorization: "Bearer synthetic-test" }, ...(payload ? { payload } : {}) }; }
|
|
function noProjectMutations(prisma, { bootstrap = false } = {}) {
|
|
for (const model of ["project", "projectMember", "projectMilestone", "projectTask", "projectRisk", "projectDeliveryRecord", "projectCommunicationLog", "projectClosureChecklistItem"]) {
|
|
for (const method of ["create", "update", "upsert"]) if (prisma[model]?.[method]) expect(prisma[model][method]).not.toHaveBeenCalled();
|
|
}
|
|
expect(prisma.auditLog.create).not.toHaveBeenCalled();
|
|
if (!bootstrap) expect(prisma.projectClosureChecklistItem.createMany).not.toHaveBeenCalled();
|
|
}
|
|
function expectProjectError(response, status, reasonCode, details) { expect(response.statusCode).toBe(status); expect(response.json().error).toMatchObject({ code: "VALID_001", details: { ...details, reasonCode } }); }
|
|
const projectInputOperations = [
|
|
["POST", "", "create_input_invalid"], ["PATCH", `/${PROJECT_ID}`, "update_input_invalid"],
|
|
...[["members", "member"], ["milestones", "milestone"], ["tasks", "task"], ["risks", "risk"], ["communication-logs", "communication_log"]].flatMap(([path, reason]) => [["POST", `/${PROJECT_ID}/${path}`, `${reason}_create_input_invalid`], ["PATCH", `/${PROJECT_ID}/${path}/${ERROR_CHILD_ID}`, `${reason}_update_input_invalid`]]),
|
|
["PATCH", `/${PROJECT_ID}/closure-checklist/${ERROR_CHILD_ID}`, "closure_checklist_update_input_invalid"],
|
|
["POST", `/${PROJECT_ID}/deliveries`, "delivery_create_input_invalid"],
|
|
];
|
|
it.each(projectInputOperations)("explains %s %s invalid input without target mutations", async (method, suffix, reason) => {
|
|
const { app, prisma } = await errorContext(); const response = await app.inject(errorRequest(method, suffix, {}));
|
|
expectProjectError(response, 400, `project.${reason}`, { formErrors: expect.any(Array), fieldErrors: expect.any(Object) }); noProjectMutations(prisma);
|
|
});
|
|
it.each([
|
|
["/bad", "id", "id_invalid"],
|
|
...[["members", "memberId", "member"], ["milestones", "milestoneId", "milestone"], ["tasks", "taskId", "task"], ["risks", "riskId", "risk"], ["communication-logs", "logId", "communication_log"], ["closure-checklist", "itemId", "closure_checklist"]].map(([path, key, reason]) => [`/${PROJECT_ID}/${path}/bad`, key, `${reason}_id_invalid`]),
|
|
])("explains invalid project reference %s", async (suffix, key, reason) => {
|
|
const { app, prisma } = await errorContext(); expectProjectError(await app.inject(errorRequest("PATCH", suffix, {})), 400, `project.${reason}`, { [key]: "invalid_uuid" }); noProjectMutations(prisma);
|
|
});
|
|
it.each([
|
|
["", "project_domain_v1", "feature_disabled", "projectDomainEnabled"],
|
|
[`/${PROJECT_ID}/weekly-reports`, "project_linking_v1", "linking_disabled", "projectLinkingEnabled"],
|
|
[`/${PROJECT_ID}/communication-logs`, "project_communication_log_v1", "communication_disabled", "projectCommunicationLogEnabled"],
|
|
[`/${PROJECT_ID}/closure-checklist`, "project_closure_checklist_v1", "closure_disabled", "projectClosureChecklistEnabled"],
|
|
[`/${PROJECT_ID}/document-refs`, "confidential_doc_refs_v1", "document_refs_disabled", "confidentialDocRefsEnabled"],
|
|
].flatMap((row) => [false, true].map((envOff) => [...row, envOff])))("preserves %s feature gate %s before business access", async (suffix, flag, reason, configKey, envOff) => {
|
|
const { app, prisma } = await errorContext();
|
|
if (envOff) app.config[configKey] = false;
|
|
else prisma.featureFlag.findUnique.mockImplementation(async ({ where }) => ({ ...buildFeatureFlagRecord(where.flag_key), override_mode: "force_off" }));
|
|
expectProjectError(await app.inject(errorRequest("GET", suffix)), 409, `project.${reason}`, { featureFlag: `${flag}_disabled`, reason: envOff ? "env_hard_off" : "flag_force_off" });
|
|
expect(prisma.project.findUnique).not.toHaveBeenCalled(); expect(prisma.project.findMany).not.toHaveBeenCalled(); noProjectMutations(prisma);
|
|
if (envOff) expect(prisma.featureFlag.findUnique).not.toHaveBeenCalled();
|
|
});
|
|
it("explains invalid project query after the feature gate", async () => {
|
|
const { app, prisma } = await errorContext(); expectProjectError(await app.inject(errorRequest("GET", "?mine=invalid")), 400, "project.query_invalid", { fieldErrors: { mine: expect.any(Array) } }); expect(prisma.project.findMany).not.toHaveBeenCalled(); noProjectMutations(prisma);
|
|
});
|
|
it.each(["status", "clear-note"])("keeps waived note guard on %s", async (mode) => {
|
|
const { app, prisma, state } = await errorContext(); if (mode === "clear-note") { state.closureChecklistItems[0].status = "waived"; state.closureChecklistItems[0].note = "合成理由"; }
|
|
expectProjectError(await app.inject(errorRequest("PATCH", `/${PROJECT_ID}/closure-checklist/${ERROR_CHILD_ID}`, mode === "status" ? { status: "waived", note: " " } : { note: null })), 400, "project.waiver_note_required", { note: "waived_requires_note" }); noProjectMutations(prisma);
|
|
});
|
|
it.each(["invalid-id", "invalid-body"])("documents existing checklist bootstrap before %s validation", async (mode) => {
|
|
const { app, prisma, state } = await errorContext({ emptyChecklist: true });
|
|
const firstId = "99999999-9999-4999-8999-000000000100";
|
|
const response = await app.inject(errorRequest("PATCH", `/${PROJECT_ID}/closure-checklist/${mode === "invalid-id" ? "bad" : firstId}`, {}));
|
|
expectProjectError(response, 400, `project.closure_checklist_${mode === "invalid-id" ? "id_invalid" : "update_input_invalid"}`, {});
|
|
expect(prisma.projectClosureChecklistItem.createMany).toHaveBeenCalledTimes(1); expect(state.closureChecklistItems).toHaveLength(6); noProjectMutations(prisma, { bootstrap: true });
|
|
});
|
|
it.each(projectInputOperations.filter(([,suffix]) => !suffix.includes("closure-checklist")))("keeps permission before %s %s validation", async (method, suffix) => {
|
|
const { app, prisma } = await errorContext({ employee: { id: OUTSIDER_ID, permissionCodes: [] } }); const response = await app.inject(errorRequest(method, suffix, {})); expect(response.statusCode).toBe(403); expect(response.json().error.code).toBe("PERM_001"); noProjectMutations(prisma);
|
|
});
|
|
it.each([
|
|
["members", "projectMember", { employeeId: MEMBER_ID }, { role: "observer" }],
|
|
["milestones", "projectMilestone", { title: "合成里程碑" }, { title: "合成修改" }],
|
|
["tasks", "projectTask", { title: "合成任务" }, { priority: "high" }],
|
|
["risks", "projectRisk", { title: "合成风险", detail: "合成说明" }, { level: "high" }],
|
|
].flatMap((row) => ["POST", "PATCH"].map((method) => [...row, method])))("preserves valid %s %s operation", async (path, model, createPayload, patchPayload, method) => {
|
|
const { app, prisma } = await errorContext(); const response = await app.inject(errorRequest(method, `/${PROJECT_ID}/${path}${method === "PATCH" ? `/${ERROR_CHILD_ID}` : ""}`, method === "POST" ? createPayload : patchPayload)); expect(response.statusCode).toBe(method === "POST" ? 201 : 200);
|
|
expect(prisma[model][method === "PATCH" ? "update" : model === "projectMember" ? "upsert" : "create"]).toHaveBeenCalledTimes(1);
|
|
});
|
|
it("preserves valid project create and delivery create", async () => {
|
|
const { app, prisma } = await errorContext(); const created = await app.inject(errorRequest("POST", "", { projectNo: "SYNTHETIC", name: "合成项目", clientName: "合成客户" })); expect(created.statusCode).toBe(201); expect(prisma.project.create).toHaveBeenCalledTimes(1);
|
|
const delivery = await app.inject(errorRequest("POST", `/${PROJECT_ID}/deliveries`, { title: "合成交付", recordType: "handover", summary: "合成说明", occurredAt: "2026-01-01T00:00:00Z" })); expect(delivery.statusCode).toBe(201); expect(prisma.projectDeliveryRecord.create).toHaveBeenCalledTimes(1);
|
|
});
|
|
it("preserves valid waived note and completion metadata", async () => {
|
|
const { app, prisma } = await errorContext(); const response = await app.inject(errorRequest("PATCH", `/${PROJECT_ID}/closure-checklist/${ERROR_CHILD_ID}`, { status: "waived", note: "合成理由" })); expect(response.statusCode).toBe(200);
|
|
expect(prisma.projectClosureChecklistItem.update).toHaveBeenCalledWith(expect.objectContaining({ data: { status: "waived", note: "合成理由", completed_at: expect.any(Date), completed_by: OWNER_ID } })); expect(prisma.auditLog.create).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("allocates project numbers inside creation and reserves formal matching codes", async () => {
|
|
const { app, prisma } = await errorContext(); enableNumbering(prisma);
|
|
const response = await app.inject(errorRequest("POST", "", { name: "合成年度项目", clientName: "合成客户" }));
|
|
expect(response.statusCode).toBe(201);
|
|
expect(prisma.project.create.mock.calls[0][0].data.project_no).toMatch(/^PRJ-\d{4}-0001$/);
|
|
const formal = await app.inject(errorRequest("POST", "", { projectNo: "PRJ-2026-0050", name: "合成手工号", clientName: "合成客户" }));
|
|
expect(formal.statusCode).toBe(201);
|
|
expect(prisma.project.create.mock.calls[1][0].data.project_no).toBe("PRJ-2026-0050");
|
|
expect(prisma.businessNumberCounter.upsert.mock.calls.at(-1)[0].update.current_number).toBe(50n);
|
|
});
|