735 行
24 KiB
JavaScript
735 行
24 KiB
JavaScript
const fs = require("node:fs/promises");
|
|
const os = require("node:os");
|
|
const path = require("node:path");
|
|
|
|
const Fastify = require("fastify");
|
|
const multipart = require("@fastify/multipart");
|
|
|
|
const { AppError } = require("../../../src/utils/AppError");
|
|
const featureFlags = require("../../../src/services/featureFlags");
|
|
const notifications = require("../../../src/services/notifications");
|
|
const email = require("../../../src/services/email");
|
|
const notificationDispatcher = require("../../../src/services/notificationDispatcher");
|
|
const erpJournal = require("../../../src/services/integrations/erpJournal");
|
|
|
|
const evaluateFeatureFlagMock = vi.fn();
|
|
const createNotificationsWithRecordsMock = vi.fn(async () => []);
|
|
const sendNotificationEmailSafeMock = vi.fn(async () => undefined);
|
|
const flushNotificationDispatchTasksMock = vi.fn(async () => undefined);
|
|
const enqueueReimbursementJournalExportMock = vi.fn(async () => ({
|
|
id: "outbox-1",
|
|
status: "pending",
|
|
duplicated: false,
|
|
requeued: false,
|
|
}));
|
|
|
|
const originalEvaluateFeatureFlag = featureFlags.evaluateFeatureFlag;
|
|
const originalCreateNotificationsWithRecords = notifications.createNotificationsWithRecords;
|
|
const originalSendNotificationEmailSafe = email.sendNotificationEmailSafe;
|
|
const originalFlushNotificationDispatchTasks = notificationDispatcher.flushNotificationDispatchTasks;
|
|
const originalEnqueueReimbursementJournalExport = erpJournal.enqueueReimbursementJournalExport;
|
|
|
|
featureFlags.evaluateFeatureFlag = evaluateFeatureFlagMock;
|
|
notifications.createNotificationsWithRecords = createNotificationsWithRecordsMock;
|
|
email.sendNotificationEmailSafe = sendNotificationEmailSafeMock;
|
|
notificationDispatcher.flushNotificationDispatchTasks = flushNotificationDispatchTasksMock;
|
|
erpJournal.enqueueReimbursementJournalExport = enqueueReimbursementJournalExportMock;
|
|
|
|
delete require.cache[require.resolve("../../../src/routes/paymentBatches")];
|
|
const paymentBatchesRoutes = require("../../../src/routes/paymentBatches");
|
|
|
|
const ACTOR_ID = "11111111-1111-4111-8111-111111111111";
|
|
const MAKER_ID = "22222222-2222-4222-8222-222222222222";
|
|
const REVIEWER_ID = "33333333-3333-4333-8333-333333333333";
|
|
const REIMBURSEMENT_ID = "44444444-4444-4444-8444-444444444444";
|
|
const BATCH_ID = "55555555-5555-4555-8555-555555555555";
|
|
const ITEM_ID = "66666666-6666-4666-8666-666666666666";
|
|
const OWNER_ID = "77777777-7777-4777-8777-777777777777";
|
|
const SUBMITTER_ID = "88888888-8888-4888-8888-888888888888";
|
|
const RECEIPT_ID = "99999999-9999-4999-8999-999999999999";
|
|
|
|
function buildMultipartRequest({ files, fields = {} }) {
|
|
const boundary = "----codex-payment-batch-receipt-boundary";
|
|
const segments = [];
|
|
|
|
for (const [name, value] of Object.entries(fields)) {
|
|
segments.push(
|
|
Buffer.from(
|
|
`--${boundary}\r\nContent-Disposition: form-data; name="${name}"\r\n\r\n${value}\r\n`,
|
|
),
|
|
);
|
|
}
|
|
|
|
for (const file of files) {
|
|
segments.push(
|
|
Buffer.from(
|
|
`--${boundary}\r\nContent-Disposition: form-data; name="files"; filename="${file.filename}"\r\nContent-Type: ${file.contentType}\r\n\r\n`,
|
|
),
|
|
Buffer.isBuffer(file.content) ? file.content : Buffer.from(file.content, "utf8"),
|
|
Buffer.from("\r\n"),
|
|
);
|
|
}
|
|
|
|
segments.push(Buffer.from(`--${boundary}--\r\n`));
|
|
|
|
return {
|
|
payload: Buffer.concat(segments),
|
|
headers: {
|
|
"content-type": `multipart/form-data; boundary=${boundary}`,
|
|
},
|
|
};
|
|
}
|
|
|
|
function buildPaymentBatch(overrides = {}) {
|
|
return {
|
|
id: BATCH_ID,
|
|
batch_no: "PB-20260429-001",
|
|
entity_type: "reimbursement",
|
|
name: "报销付款批次",
|
|
status: "reviewed",
|
|
default_payment_date: new Date("2026-04-29T00:00:00.000Z"),
|
|
default_payment_channel: "bank",
|
|
voucher_prefix: "PBX",
|
|
created_by: MAKER_ID,
|
|
reviewed_at: new Date("2026-04-29T08:00:00.000Z"),
|
|
reviewed_by: REVIEWER_ID,
|
|
secondary_reviewed_at: null,
|
|
secondary_reviewed_by: null,
|
|
executed_at: null,
|
|
executed_by: null,
|
|
cancelled_at: null,
|
|
cancelled_by: null,
|
|
review_comment: null,
|
|
secondary_review_comment: null,
|
|
execution_summary_json: null,
|
|
created_at: new Date("2026-04-29T07:00:00.000Z"),
|
|
updated_by: MAKER_ID,
|
|
items: [
|
|
{
|
|
id: ITEM_ID,
|
|
payment_batch_id: BATCH_ID,
|
|
entity_id: REIMBURSEMENT_ID,
|
|
entity_code: "BX-20260429-0001",
|
|
entity_title: "研发报销",
|
|
amount: "1683.00",
|
|
currency_code: "CNY",
|
|
status: "pending",
|
|
payment_voucher_no_override: null,
|
|
payment_date_override: null,
|
|
payment_channel_override: null,
|
|
failure_code: null,
|
|
failure_message: null,
|
|
snapshot_json: {},
|
|
created_at: new Date("2026-04-29T07:00:00.000Z"),
|
|
},
|
|
],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildReimbursement(overrides = {}) {
|
|
return {
|
|
id: REIMBURSEMENT_ID,
|
|
status: "approved",
|
|
form_number: "BX-20260429-0001",
|
|
owner_id: OWNER_ID,
|
|
submitter_id: SUBMITTER_ID,
|
|
department_id: "dept-1",
|
|
total_amount: "1683.00",
|
|
payment_voucher_no: null,
|
|
payment_date: null,
|
|
payment_channel: null,
|
|
paid_at: null,
|
|
paid_by: null,
|
|
owner: {
|
|
legal_entity: {
|
|
code: "HYB",
|
|
},
|
|
},
|
|
submitter: {
|
|
legal_entity: {
|
|
code: "HYB",
|
|
},
|
|
},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function buildPrisma(options = {}) {
|
|
const defaultReceiptAttachments = [
|
|
{
|
|
id: RECEIPT_ID,
|
|
payment_batch_id: BATCH_ID,
|
|
storage_path: "payment-batch-receipts/20260429/receipt.pdf",
|
|
original_name: "receipt.pdf",
|
|
mime_type: "application/pdf",
|
|
file_size: 12,
|
|
file_sha256: "sha256-receipt",
|
|
uploaded_by: ACTOR_ID,
|
|
created_at: new Date("2026-04-29T09:00:00.000Z"),
|
|
uploader: {
|
|
id: ACTOR_ID,
|
|
employee_no: "FIN001",
|
|
name: "出纳",
|
|
},
|
|
},
|
|
];
|
|
const state = {
|
|
batch: buildPaymentBatch(options.batch),
|
|
reimbursement: buildReimbursement(options.reimbursement),
|
|
receiptAttachments: options.receiptAttachments ?? defaultReceiptAttachments,
|
|
invoice: {
|
|
linked_reimbursement_id: REIMBURSEMENT_ID,
|
|
status: "bound",
|
|
linked_item_id: "invoice-item-1",
|
|
archived_reason: null,
|
|
archived_at: null,
|
|
updated_by: null,
|
|
...(options.invoice ?? {}),
|
|
},
|
|
};
|
|
|
|
const tx = {
|
|
paymentBatch: {
|
|
findUnique: vi.fn(async ({ where }) => {
|
|
if (where.id !== state.batch.id) {
|
|
return null;
|
|
}
|
|
return {
|
|
...state.batch,
|
|
items: state.batch.items.map((item) => ({ ...item })),
|
|
};
|
|
}),
|
|
update: vi.fn(async ({ where, data }) => {
|
|
if (where.id !== state.batch.id) {
|
|
throw new Error("batch not found");
|
|
}
|
|
state.batch = {
|
|
...state.batch,
|
|
...data,
|
|
};
|
|
return {
|
|
...state.batch,
|
|
items: state.batch.items.map((item) => ({ ...item })),
|
|
};
|
|
}),
|
|
},
|
|
paymentBatchItem: {
|
|
update: vi.fn(async ({ where, data }) => {
|
|
const item = state.batch.items.find((entry) => entry.id === where.id);
|
|
if (!item) {
|
|
throw new Error("item not found");
|
|
}
|
|
Object.assign(item, data);
|
|
return { ...item };
|
|
}),
|
|
},
|
|
paymentBatchReceiptAttachment: {
|
|
count: vi.fn(async ({ where }) =>
|
|
state.receiptAttachments.filter((item) => item.payment_batch_id === where.payment_batch_id).length,
|
|
),
|
|
findMany: vi.fn(async ({ where }) =>
|
|
state.receiptAttachments
|
|
.filter((item) => item.payment_batch_id === where.payment_batch_id)
|
|
.map((item) => ({ ...item })),
|
|
),
|
|
create: vi.fn(async ({ data }) => {
|
|
const created = {
|
|
id: `aaaaaaaa-aaaa-4aaa-8aaa-${String(state.receiptAttachments.length + 1).padStart(12, "0")}`,
|
|
...data,
|
|
created_at: new Date("2026-04-29T10:00:00.000Z"),
|
|
uploader: {
|
|
id: ACTOR_ID,
|
|
employee_no: "FIN001",
|
|
name: "出纳",
|
|
},
|
|
};
|
|
state.receiptAttachments.push(created);
|
|
return { ...created };
|
|
}),
|
|
findFirst: vi.fn(async ({ where }) => {
|
|
const item = state.receiptAttachments.find(
|
|
(candidate) => candidate.id === where.id && candidate.payment_batch_id === where.payment_batch_id,
|
|
);
|
|
return item ? { ...item } : null;
|
|
}),
|
|
deleteMany: vi.fn(async ({ where }) => {
|
|
const before = state.receiptAttachments.length;
|
|
state.receiptAttachments = state.receiptAttachments.filter(
|
|
(item) => !(item.id === where.id && item.payment_batch_id === where.payment_batch_id),
|
|
);
|
|
return { count: before - state.receiptAttachments.length };
|
|
}),
|
|
},
|
|
reimbursementForm: {
|
|
findUnique: vi.fn(async ({ where }) => {
|
|
if (where.id !== state.reimbursement.id) {
|
|
return null;
|
|
}
|
|
return { ...state.reimbursement };
|
|
}),
|
|
update: vi.fn(async ({ where, data }) => {
|
|
if (where.id !== state.reimbursement.id) {
|
|
throw new Error("reimbursement not found");
|
|
}
|
|
state.reimbursement = {
|
|
...state.reimbursement,
|
|
...data,
|
|
};
|
|
return { ...state.reimbursement };
|
|
}),
|
|
},
|
|
invoicePool: {
|
|
updateMany: vi.fn(async ({ where, data }) => {
|
|
const matches =
|
|
state.invoice.linked_reimbursement_id === where.linked_reimbursement_id &&
|
|
state.invoice.status === where.status;
|
|
if (!matches) {
|
|
return { count: 0 };
|
|
}
|
|
state.invoice = {
|
|
...state.invoice,
|
|
...data,
|
|
};
|
|
return { count: 1 };
|
|
}),
|
|
},
|
|
entityRiskFlag: {
|
|
findMany: vi.fn(async () => []),
|
|
findFirst: vi.fn(async () => null),
|
|
updateMany: vi.fn(async () => ({ count: 0 })),
|
|
create: vi.fn(async ({ data }) => ({ id: "risk-1", ...data })),
|
|
},
|
|
auditLog: {
|
|
create: vi.fn(async () => ({ id: "audit-1" })),
|
|
},
|
|
};
|
|
|
|
const prisma = {
|
|
...tx,
|
|
$transaction: vi.fn(async (callback) => callback(tx)),
|
|
};
|
|
|
|
return { prisma, tx, state };
|
|
}
|
|
|
|
async function buildApp(options = {}) {
|
|
const { prisma, tx, state } = buildPrisma(options);
|
|
const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "hyb-oa-cashv-payment-receipts-"));
|
|
const app = Fastify();
|
|
const actor = options.actor ?? {
|
|
id: ACTOR_ID,
|
|
department_id: "dept-1",
|
|
permissionCodes: ["payment.batch.manage", "risk.review.manage"],
|
|
};
|
|
const paymentBatchEnabled = options.paymentBatchEnabled ?? true;
|
|
const erpSyncEnabled = options.erpSyncEnabled ?? true;
|
|
|
|
evaluateFeatureFlagMock.mockImplementation(async ({ flagKey }) => {
|
|
if (flagKey === featureFlags.FEATURE_FLAG_KEYS.paymentBatch) {
|
|
return {
|
|
flagKey,
|
|
enabled: paymentBatchEnabled,
|
|
reason: paymentBatchEnabled ? "mock_on" : "mock_off",
|
|
envEnabled: paymentBatchEnabled,
|
|
matchedDepartmentId: null,
|
|
requiresDepartment: false,
|
|
};
|
|
}
|
|
if (flagKey === featureFlags.FEATURE_FLAG_KEYS.erpSync) {
|
|
return {
|
|
flagKey,
|
|
enabled: erpSyncEnabled,
|
|
reason: erpSyncEnabled ? "mock_on" : "mock_off",
|
|
envEnabled: erpSyncEnabled,
|
|
matchedDepartmentId: null,
|
|
requiresDepartment: false,
|
|
};
|
|
}
|
|
return {
|
|
flagKey,
|
|
enabled: false,
|
|
reason: "mock_off",
|
|
envEnabled: false,
|
|
matchedDepartmentId: null,
|
|
requiresDepartment: false,
|
|
};
|
|
});
|
|
|
|
app.decorate("prisma", prisma);
|
|
app.decorate("config", {
|
|
appTimezone: "Asia/Shanghai",
|
|
storageDir: tempDir,
|
|
maxUploadSizeBytes: 5 * 1024 * 1024,
|
|
paymentBatchEnabled: true,
|
|
erpSyncEnabled: true,
|
|
integrationOutboxMaxAttempts: 5,
|
|
imNotifierEnabled: false,
|
|
appOrigin: "http://127.0.0.1:3001",
|
|
});
|
|
app.decorate("authenticate", async (request) => {
|
|
if (!request.headers.authorization) {
|
|
throw new AppError({ code: "AUTH_001", message: "未登录", statusCode: 401 });
|
|
}
|
|
request.employee = actor;
|
|
});
|
|
app.decorate("hasPermission", (employee, permissionCode) =>
|
|
(employee?.permissionCodes ?? []).includes("*") || (employee?.permissionCodes ?? []).includes(permissionCode),
|
|
);
|
|
app.decorate("requirePermission", (permissionCode) => async (request) => {
|
|
await app.authenticate(request);
|
|
if (!app.hasPermission(request.employee, permissionCode)) {
|
|
throw new AppError({ code: "PERM_001", message: "无权限", statusCode: 403 });
|
|
}
|
|
});
|
|
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(multipart, {
|
|
attachFieldsToBody: false,
|
|
limits: { files: 5, fileSize: 5 * 1024 * 1024 },
|
|
});
|
|
await app.register(paymentBatchesRoutes, { prefix: "/api" });
|
|
|
|
return { app, prisma, tx, state, tempDir };
|
|
}
|
|
|
|
afterEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
afterAll(() => {
|
|
featureFlags.evaluateFeatureFlag = originalEvaluateFeatureFlag;
|
|
notifications.createNotificationsWithRecords = originalCreateNotificationsWithRecords;
|
|
email.sendNotificationEmailSafe = originalSendNotificationEmailSafe;
|
|
notificationDispatcher.flushNotificationDispatchTasks = originalFlushNotificationDispatchTasks;
|
|
erpJournal.enqueueReimbursementJournalExport = originalEnqueueReimbursementJournalExport;
|
|
});
|
|
|
|
describe("payment batch reimbursement routes", () => {
|
|
it("executes reimbursement batch payment and queues downstream follow-ups", async () => {
|
|
createNotificationsWithRecordsMock.mockResolvedValueOnce([
|
|
{ id: "notif-1", recipient_employee_id: OWNER_ID },
|
|
{ id: "notif-2", recipient_employee_id: SUBMITTER_ID },
|
|
]);
|
|
|
|
const { app, tx, state } = await buildApp();
|
|
|
|
const response = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/execute`,
|
|
headers: { authorization: "Bearer test" },
|
|
payload: {},
|
|
});
|
|
|
|
expect(response.statusCode).toBe(200);
|
|
expect(response.json().data.item.status).toBe("executed");
|
|
expect(state.batch.status).toBe("executed");
|
|
expect(state.batch.items[0].status).toBe("executed");
|
|
expect(state.reimbursement.status).toBe("paid");
|
|
expect(state.reimbursement.payment_voucher_no).toBe("PBX-001");
|
|
expect(state.reimbursement.payment_channel).toBe("bank");
|
|
expect(state.invoice.status).toBe("archived");
|
|
expect(state.invoice.archived_reason).toBe("used_complete");
|
|
expect(tx.invoicePool.updateMany).toHaveBeenCalledWith({
|
|
where: {
|
|
linked_reimbursement_id: REIMBURSEMENT_ID,
|
|
status: "bound",
|
|
},
|
|
data: expect.objectContaining({
|
|
status: "archived",
|
|
archived_reason: "used_complete",
|
|
updated_by: ACTOR_ID,
|
|
}),
|
|
});
|
|
expect(enqueueReimbursementJournalExportMock).toHaveBeenCalledWith(
|
|
expect.any(Object),
|
|
expect.objectContaining({
|
|
paymentBatchEnabled: true,
|
|
erpSyncEnabled: true,
|
|
}),
|
|
expect.objectContaining({
|
|
actorId: ACTOR_ID,
|
|
reimbursement: expect.objectContaining({
|
|
id: REIMBURSEMENT_ID,
|
|
status: "paid",
|
|
}),
|
|
}),
|
|
);
|
|
expect(createNotificationsWithRecordsMock).toHaveBeenCalledWith(
|
|
expect.any(Object),
|
|
expect.objectContaining({
|
|
recipientEmployeeIds: [OWNER_ID, SUBMITTER_ID],
|
|
targetId: REIMBURSEMENT_ID,
|
|
}),
|
|
);
|
|
expect(flushNotificationDispatchTasksMock).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
tasks: expect.arrayContaining([
|
|
expect.objectContaining({
|
|
targetId: REIMBURSEMENT_ID,
|
|
type: "reimbursement.paid",
|
|
}),
|
|
]),
|
|
}),
|
|
);
|
|
|
|
await app.close();
|
|
});
|
|
|
|
it("rejects first review when maker tries to review own batch", async () => {
|
|
const { app } = await buildApp({
|
|
actor: {
|
|
id: MAKER_ID,
|
|
department_id: "dept-1",
|
|
permissionCodes: ["risk.review.manage"],
|
|
},
|
|
batch: {
|
|
status: "draft",
|
|
reviewed_at: null,
|
|
reviewed_by: null,
|
|
},
|
|
});
|
|
|
|
const response = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/review`,
|
|
headers: { authorization: "Bearer test" },
|
|
payload: {},
|
|
});
|
|
|
|
expect(response.statusCode).toBe(409);
|
|
expect(response.json().error.details.review).toBe("maker_checker_conflict");
|
|
|
|
await app.close();
|
|
});
|
|
|
|
it("rejects bank-channel execution when no bank receipt attachment exists", async () => {
|
|
const { app, state } = await buildApp({ receiptAttachments: [] });
|
|
|
|
const response = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/execute`,
|
|
headers: { authorization: "Bearer test" },
|
|
payload: {},
|
|
});
|
|
|
|
expect(response.statusCode).toBe(409);
|
|
expect(response.json().error.details.receiptAttachments).toBe("bank_receipt_required");
|
|
expect(state.batch.status).toBe("reviewed");
|
|
expect(state.reimbursement.status).toBe("approved");
|
|
expect(enqueueReimbursementJournalExportMock).not.toHaveBeenCalled();
|
|
|
|
await app.close();
|
|
});
|
|
|
|
it("allows payment metadata updates after review before execution", async () => {
|
|
const { app, state } = await buildApp();
|
|
|
|
const response = await app.inject({
|
|
method: "PATCH",
|
|
url: `/api/payment-batches/${BATCH_ID}/items/${ITEM_ID}`,
|
|
headers: { authorization: "Bearer test" },
|
|
payload: {
|
|
paymentVoucherNoOverride: "BANK-RECEIPT-001",
|
|
paymentDateOverride: "2026-04-30",
|
|
paymentChannelOverride: "bank",
|
|
},
|
|
});
|
|
|
|
expect(response.statusCode).toBe(200);
|
|
expect(response.json().data.item).toMatchObject({
|
|
paymentVoucherNoOverride: "BANK-RECEIPT-001",
|
|
paymentDateOverride: "2026-04-30",
|
|
paymentChannelOverride: "bank",
|
|
});
|
|
expect(state.batch.items[0]).toMatchObject({
|
|
payment_voucher_no_override: "BANK-RECEIPT-001",
|
|
payment_channel_override: "bank",
|
|
});
|
|
|
|
await app.close();
|
|
});
|
|
|
|
it("uploads, downloads and deletes bank receipt attachments", async () => {
|
|
const { app, prisma, state, tempDir } = await buildApp({ receiptAttachments: [] });
|
|
|
|
try {
|
|
const requestPayload = buildMultipartRequest({
|
|
files: [
|
|
{
|
|
filename: "bank-receipt.pdf",
|
|
contentType: "application/pdf",
|
|
content: "%PDF bank receipt",
|
|
},
|
|
],
|
|
});
|
|
|
|
const uploadResponse = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments`,
|
|
headers: {
|
|
authorization: "Bearer test",
|
|
...requestPayload.headers,
|
|
},
|
|
payload: requestPayload.payload,
|
|
});
|
|
|
|
expect(uploadResponse.statusCode).toBe(200);
|
|
expect(uploadResponse.json().data.items).toHaveLength(1);
|
|
expect(uploadResponse.json().data.items[0]).toMatchObject({
|
|
originalName: "bank-receipt.pdf",
|
|
mimeType: "application/pdf",
|
|
governanceStatus: "approved",
|
|
sensitivityLevel: "confidential",
|
|
attachmentType: "receipt",
|
|
downloadPolicy: "reason_required",
|
|
});
|
|
const attachmentId = uploadResponse.json().data.items[0].id;
|
|
expect(prisma.paymentBatchReceiptAttachment.create).toHaveBeenCalledTimes(1);
|
|
expect(prisma.auditLog.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({
|
|
action: "PAYMENT_BATCH_RECEIPT_UPLOADED",
|
|
target_id: BATCH_ID,
|
|
}),
|
|
}),
|
|
);
|
|
|
|
const storedPath = state.receiptAttachments[0].storage_path;
|
|
const stored = await fs.readFile(path.join(tempDir, storedPath));
|
|
expect(stored.toString("utf8")).toBe("%PDF bank receipt");
|
|
|
|
const listResponse = await app.inject({
|
|
method: "GET",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments`,
|
|
headers: { authorization: "Bearer test" },
|
|
});
|
|
expect(listResponse.statusCode).toBe(200);
|
|
expect(listResponse.json().data.items).toHaveLength(1);
|
|
expect(listResponse.json().data.items[0]).toMatchObject({
|
|
governanceStatus: "approved",
|
|
sensitivityLevel: "confidential",
|
|
attachmentType: "receipt",
|
|
downloadPolicy: "reason_required",
|
|
});
|
|
|
|
const missingReasonResponse = await app.inject({
|
|
method: "GET",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments/${attachmentId}/file`,
|
|
headers: { authorization: "Bearer test" },
|
|
});
|
|
expect(missingReasonResponse.statusCode).toBe(400);
|
|
expect(missingReasonResponse.json().error.details).toEqual({ reason: "required" });
|
|
|
|
const downloadResponse = await app.inject({
|
|
method: "GET",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments/${attachmentId}/file?reason=付款复核`,
|
|
headers: { authorization: "Bearer test" },
|
|
});
|
|
expect(downloadResponse.statusCode).toBe(200);
|
|
expect(downloadResponse.body).toBe("%PDF bank receipt");
|
|
expect(prisma.auditLog.create).toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
data: expect.objectContaining({
|
|
action: "PAYMENT_BATCH_RECEIPT_DOWNLOADED",
|
|
target_id: BATCH_ID,
|
|
extra: expect.objectContaining({
|
|
attachmentId,
|
|
attachmentType: "receipt",
|
|
sensitivityLevel: "confidential",
|
|
governanceStatus: "approved",
|
|
reason: "付款复核",
|
|
}),
|
|
}),
|
|
}),
|
|
);
|
|
|
|
const deleteResponse = await app.inject({
|
|
method: "DELETE",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments/${attachmentId}`,
|
|
headers: { authorization: "Bearer test" },
|
|
});
|
|
expect(deleteResponse.statusCode).toBe(200);
|
|
expect(state.receiptAttachments).toHaveLength(0);
|
|
} finally {
|
|
await app.close();
|
|
await fs.rm(tempDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("rejects unsupported bank receipt attachment MIME types", async () => {
|
|
const { app, tempDir } = await buildApp({ receiptAttachments: [] });
|
|
|
|
try {
|
|
const requestPayload = buildMultipartRequest({
|
|
files: [
|
|
{
|
|
filename: "receipt.txt",
|
|
contentType: "text/plain",
|
|
content: "not a receipt attachment type",
|
|
},
|
|
],
|
|
});
|
|
|
|
const response = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/receipt-attachments`,
|
|
headers: {
|
|
authorization: "Bearer test",
|
|
...requestPayload.headers,
|
|
},
|
|
payload: requestPayload.payload,
|
|
});
|
|
|
|
expect(response.statusCode).toBe(400);
|
|
expect(response.json().error.details.file).toBe("unsupported_mime_type");
|
|
} finally {
|
|
await app.close();
|
|
await fs.rm(tempDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("marks batch item failed when reimbursement is not payable and does not queue follow-ups", async () => {
|
|
const { app, state } = await buildApp({
|
|
reimbursement: {
|
|
status: "reviewing",
|
|
},
|
|
});
|
|
|
|
const response = await app.inject({
|
|
method: "POST",
|
|
url: `/api/payment-batches/${BATCH_ID}/execute`,
|
|
headers: { authorization: "Bearer test" },
|
|
payload: {},
|
|
});
|
|
|
|
expect(response.statusCode).toBe(200);
|
|
expect(response.json().data.item.status).toBe("failed");
|
|
expect(state.batch.status).toBe("failed");
|
|
expect(state.batch.items[0].status).toBe("failed");
|
|
expect(state.batch.items[0].failure_code).toBe("VALID_001");
|
|
expect(state.reimbursement.status).toBe("reviewing");
|
|
expect(state.invoice.status).toBe("bound");
|
|
expect(enqueueReimbursementJournalExportMock).not.toHaveBeenCalled();
|
|
expect(createNotificationsWithRecordsMock).not.toHaveBeenCalled();
|
|
|
|
await app.close();
|
|
});
|
|
});
|