Files
lik 84461e9445 fix: 避免识别异常与支付锁泄漏
修复 ASR 取消后的孤立会话、OCR 表格重复及支付锁无法回收的问题,并补充回归测试。
2026-11-08 12:43:06 +08:00

242 lines
7.1 KiB
JavaScript

import { test } from "node:test";
import assert from "node:assert/strict";
import crypto from "node:crypto";
import {
yuanToFen,
fenToYuan,
formatTimeExpire,
buildRequestSignature,
buildAuthHeader,
verifyMessageSignature,
decryptAesGcm,
} from "../utils/wechatpay.js";
import { createOrderQueryCache, HandlerPayment, withPayLock, payLocks } from "../handler/payment.js";
import { DBModel } from "../models/index.js";
test("元转分按小数点拆位,不经过浮点", () => {
assert.equal(yuanToFen("500.00"), 50000);
assert.equal(yuanToFen("500.5"), 50050);
assert.equal(yuanToFen(500), 50000);
assert.equal(yuanToFen("0.01"), 1);
assert.equal(yuanToFen("0.00"), 0);
// 超过两位小数、非数字、负数一律非法
assert.equal(yuanToFen("500.001"), null);
assert.equal(yuanToFen("abc"), null);
assert.equal(yuanToFen("-1"), null);
assert.equal(yuanToFen(""), null);
});
test("分转元固定两位小数", () => {
assert.equal(fenToYuan(50000), "500.00");
assert.equal(fenToYuan(1), "0.01");
assert.equal(fenToYuan(1.5), "");
});
test("time_expire 输出 RFC3339 北京时间", () => {
assert.equal(formatTimeExpire(new Date("2026-11-06T02:00:00.000Z")), "2026-11-06T10:00:00+08:00");
assert.equal(formatTimeExpire("invalid"), "");
});
test("请求签名可被同名公钥验证", () => {
const { privateKey, publicKey } = crypto.generateKeyPairSync("rsa", { modulusLength: 2048 });
const privatePem = privateKey.export({ type: "pkcs8", format: "pem" });
const publicPem = publicKey.export({ type: "spki", format: "pem" });
const method = "POST";
const urlPath = "/v3/pay/transactions/jsapi";
const timestamp = "1700000000";
const nonce = "abc123";
const body = '{"appid":"wx-test"}';
const signature = buildRequestSignature({ method, urlPath, timestamp, nonce, body, privateKey: privatePem });
const message = `${method}\n${urlPath}\n${timestamp}\n${nonce}\n${body}\n`;
assert.equal(verifyMessageSignature({ message, signature, publicKeyPem: publicPem }), true);
// 报文被篡改后验签失败
const tampered = `${method}\n${urlPath}\n${timestamp}\n${nonce}\n${body.replace("wx-test", "wx-evil")}\n`;
assert.equal(verifyMessageSignature({ message: tampered, signature, publicKeyPem: publicPem }), false);
});
test("Authorization 头使用 WECHATPAY2-SHA256-RSA2048 格式", () => {
const header = buildAuthHeader({
mchid: "1900000109",
serialNo: "SERIAL",
signature: "SIG",
timestamp: "1700000000",
nonce: "abc123",
});
assert.equal(
header,
'WECHATPAY2-SHA256-RSA2048 mchid="1900000109",nonce_str="abc123",signature="SIG",timestamp="1700000000",serial_no="SERIAL"'
);
});
test("AES-256-GCM 解密与 authTag 校验", () => {
const key = crypto.randomBytes(32);
const nonce = "abcdefghijkl";
const associatedData = "transaction";
const plaintext = JSON.stringify({ out_trade_no: "order-1", amount: { total: 1 } });
const cipher = crypto.createCipheriv("aes-256-gcm", key, Buffer.from(nonce, "utf-8"));
cipher.setAAD(Buffer.from(associatedData, "utf-8"));
const encrypted = Buffer.concat([cipher.update(plaintext, "utf-8"), cipher.final()]);
const authTag = cipher.getAuthTag();
const ciphertext = Buffer.concat([encrypted, authTag]).toString("base64");
const decrypted = decryptAesGcm({
ciphertext,
nonce,
associatedData,
apiV3Key: key,
});
assert.equal(decrypted, plaintext);
// 篡改密文 / 错误 authTag 必须抛错
const broken = Buffer.from(ciphertext, "base64");
broken[broken.length - 1] ^= 0xff;
assert.throws(() => decryptAesGcm({
ciphertext: broken.toString("base64"),
nonce,
associatedData,
apiV3Key: key,
}));
});
test("轮询查单在 TTL 内复用结果,过期后重新查询", async () => {
let calls = 0;
let current = 1000;
const query = createOrderQueryCache({
ttl: 3000,
now: () => current,
query: async (outTradeNo) => {
calls += 1;
return { outTradeNo, trade_state: "NOTPAY" };
},
});
const first = await query("T1");
current = 1500;
const second = await query("T1");
assert.equal(first, second);
assert.equal(calls, 1);
current = 4001;
await query("T1");
assert.equal(calls, 2);
});
test("同一订单的并发轮询共享一次上游查单", async () => {
let calls = 0;
let release;
const query = createOrderQueryCache({
query: () => {
calls += 1;
return new Promise((resolve) => {
release = () => resolve({ trade_state: "NOTPAY" });
});
},
});
const first = query("T2");
const second = query("T2");
await new Promise((resolve) => setImmediate(resolve));
assert.equal(calls, 1);
release();
const [a, b] = await Promise.all([first, second]);
assert.equal(a, b);
});
test("查单失败不写缓存,下一次仍会重试", async () => {
let calls = 0;
const query = createOrderQueryCache({
query: async () => {
calls += 1;
if (calls === 1) throw new Error("network down");
return { trade_state: "NOTPAY" };
},
});
await assert.rejects(query("T3"), /network down/);
await query("T3");
assert.equal(calls, 2);
});
test("force 可绕过轮询缓存", async () => {
let calls = 0;
const query = createOrderQueryCache({
ttl: 60_000,
query: async () => {
calls += 1;
return { trade_state: "NOTPAY" };
},
});
await query("T4");
await query("T4", { force: true });
assert.equal(calls, 2);
});
test("退款成功后的迟到处理中结果不会回退支付与订单状态", async () => {
const previous = {
RefundRecord: DBModel.RefundRecord,
PaymentRecord: DBModel.PaymentRecord,
EscortRecord: DBModel.EscortRecord,
};
let refundFilter = null;
let downstreamWrites = 0;
DBModel.RefundRecord = {
updateOne: async (filter) => {
refundFilter = filter;
return { matchedCount: 0 };
},
};
DBModel.PaymentRecord = {
updateOne: async () => { downstreamWrites += 1; },
};
DBModel.EscortRecord = {
updateOne: async () => { downstreamWrites += 1; },
};
try {
const status = await HandlerPayment.applyRefundResult(
{ _id: "r1", paymentId: "p1", recordId: "o1", status: "success" },
{ status: "PROCESSING" }
);
assert.equal(status, "success");
assert.deepEqual(refundFilter.status, { $ne: "success" });
assert.equal(downstreamWrites, 0);
} finally {
Object.assign(DBModel, previous);
}
});
test("同一订单支付锁保持串行并在完成后清理", async () => {
const key = "payment-lock-test";
const order = [];
let releaseFirst;
payLocks.delete(key);
const first = withPayLock(key, async () => {
order.push("first-start");
await new Promise((resolve) => { releaseFirst = resolve; });
order.push("first-end");
});
const second = withPayLock(key, async () => {
order.push("second-start");
order.push("second-end");
});
await new Promise((resolve) => setImmediate(resolve));
assert.deepEqual(order, ["first-start"]);
assert.equal(payLocks.has(key), true);
releaseFirst();
await Promise.all([first, second]);
assert.deepEqual(order, ["first-start", "first-end", "second-start", "second-end"]);
assert.equal(payLocks.has(key), false);
});