Codex
447 lines
19 KiB
JavaScript
447 lines
19 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import {
|
|
InventoryError,
|
|
InventoryService
|
|
} from '../dist/inventory/inventory-service.js';
|
|
|
|
const state = {
|
|
stocks: [
|
|
stock('101', '5', 10, 0, 1, 2, 'TRACKED'),
|
|
stock('102', '2', 4, 0, 0, 1, 'TRACKED'),
|
|
stock('103', '9', 0, 0, 0, 0, 'UNLIMITED')
|
|
],
|
|
skus: new Map([
|
|
['2', 'TRACKED'], ['4', 'TRACKED'], ['5', 'TRACKED'], ['9', 'UNLIMITED']
|
|
]),
|
|
inactiveSkus: new Set(),
|
|
archivedSkus: new Set(),
|
|
requests: [],
|
|
ledgers: [],
|
|
audits: [],
|
|
lockOrder: [],
|
|
nextStockId: 104,
|
|
nextLedgerId: 1001,
|
|
commits: 0,
|
|
rollbacks: 0
|
|
};
|
|
|
|
function stock(id, skuId, availableQuantity, lockedQuantity, lossQuantity,
|
|
lowStockThreshold, policyType) {
|
|
return {
|
|
id, tenantId: '7', storeId: '11', skuId, policyType,
|
|
availableQuantity, lockedQuantity, lossQuantity, lowStockThreshold, version: 1
|
|
};
|
|
}
|
|
|
|
function cloneMutableState() {
|
|
return structuredClone({
|
|
stocks: state.stocks,
|
|
requests: state.requests,
|
|
ledgers: state.ledgers,
|
|
audits: state.audits,
|
|
nextStockId: state.nextStockId,
|
|
nextLedgerId: state.nextLedgerId
|
|
});
|
|
}
|
|
|
|
let transactionSnapshot = null;
|
|
const pool = {
|
|
async getConnection() { return connection; },
|
|
async execute(sql, params = []) { return execute(sql, params); }
|
|
};
|
|
const connection = {
|
|
async beginTransaction() { transactionSnapshot = cloneMutableState(); },
|
|
async commit() { state.commits += 1; transactionSnapshot = null; },
|
|
async rollback() {
|
|
state.rollbacks += 1;
|
|
if (transactionSnapshot) {
|
|
state.stocks = transactionSnapshot.stocks;
|
|
state.requests = transactionSnapshot.requests;
|
|
state.ledgers = transactionSnapshot.ledgers;
|
|
state.audits = transactionSnapshot.audits;
|
|
state.nextStockId = transactionSnapshot.nextStockId;
|
|
state.nextLedgerId = transactionSnapshot.nextLedgerId;
|
|
}
|
|
transactionSnapshot = null;
|
|
},
|
|
release() {},
|
|
async execute(sql, params = []) { return execute(sql, params); }
|
|
};
|
|
|
|
function execute(sql, params) {
|
|
if (/\b(UPDATE|DELETE)\s+qipai_product_inventory_ledger/i.test(sql)) {
|
|
throw new Error('immutable ledger was mutated');
|
|
}
|
|
if (sql.includes('SELECT COUNT(*) AS total') && sql.includes('qipai_product_inventory_ledger')) {
|
|
const matches = state.ledgers.filter((item) => item.tenantId === String(params[0])
|
|
&& item.storeId === String(params[1]) && item.inventoryId === String(params[2]));
|
|
return [[{ total: matches.length }], []];
|
|
}
|
|
if (sql.includes('FROM qipai_product_inventory_ledger')
|
|
&& sql.includes('ORDER BY id DESC')) {
|
|
const rows = state.ledgers.filter((item) => item.tenantId === String(params[0])
|
|
&& item.storeId === String(params[1]) && item.inventoryId === String(params[2]))
|
|
.sort((left, right) => Number(right.id) - Number(left.id));
|
|
return [rows, []];
|
|
}
|
|
if (sql.includes('SELECT COUNT(*) AS total') && sql.includes('qipai_product_inventory i')) {
|
|
const matches = state.stocks.filter((item) => item.tenantId === String(params[0])
|
|
&& item.storeId === String(params[1]));
|
|
return [[{ total: matches.length }], []];
|
|
}
|
|
if (sql.includes('FROM qipai_product_inventory i') && sql.includes('ORDER BY p.sort_order')) {
|
|
const rows = state.stocks.filter((item) => item.tenantId === String(params[0])
|
|
&& item.storeId === String(params[1])).map((item) => ({
|
|
...item,
|
|
skuCode: `SKU-${item.skuId}`,
|
|
skuName: `规格 ${item.skuId}`,
|
|
productId: `8${item.skuId}`,
|
|
productCode: `P-${item.skuId}`,
|
|
productName: `商品 ${item.skuId}`,
|
|
salePriceCents: 1200
|
|
}));
|
|
return [rows, []];
|
|
}
|
|
if (sql.includes('INSERT IGNORE INTO qipai_product_inventory')) {
|
|
const tenantId = String(params[0]);
|
|
const storeId = String(params[3]);
|
|
const skuId = String(params[5]);
|
|
const existing = findStock(tenantId, storeId, skuId);
|
|
if (existing || tenantId !== '7' || storeId !== '11' || !state.skus.has(skuId)) {
|
|
return [{ affectedRows: 0 }, []];
|
|
}
|
|
state.stocks.push({
|
|
id: String(state.nextStockId++), tenantId, storeId, skuId,
|
|
policyType: state.skus.get(skuId), availableQuantity: 0, lockedQuantity: 0,
|
|
lossQuantity: 0, lowStockThreshold: 0, version: 1
|
|
});
|
|
return [{ affectedRows: 1 }, []];
|
|
}
|
|
if (sql.includes('INSERT INTO qipai_product_inventory_requests')) {
|
|
const tenantId = String(params[0]);
|
|
const requestId = String(params[2]);
|
|
if (state.requests.some((item) => item.tenantId === tenantId
|
|
&& item.requestId === requestId)) {
|
|
throw Object.assign(new Error('duplicate inventory request'), { code: 'ER_DUP_ENTRY' });
|
|
}
|
|
state.requests.push({
|
|
tenantId, storeId: String(params[1]), requestId,
|
|
operation: params[3], businessType: String(params[4]), businessId: String(params[5]),
|
|
fingerprint: String(params[6]), itemCount: Number(params[7])
|
|
});
|
|
return [{ insertId: state.requests.length, affectedRows: 1 }, []];
|
|
}
|
|
if (sql.includes('FROM qipai_product_inventory_requests') && sql.includes('FOR UPDATE')) {
|
|
const row = state.requests.find((item) => item.tenantId === String(params[0])
|
|
&& item.requestId === String(params[1]));
|
|
return [row ? [{ ...row }] : [], []];
|
|
}
|
|
if (sql.includes('SELECT product_id AS productId')
|
|
&& sql.includes('FROM qipai_product_skus')) {
|
|
const skuId = String(params[1]);
|
|
return [state.skus.has(skuId) ? [{ productId: `8${skuId}` }] : [], []];
|
|
}
|
|
if (sql.includes('SELECT id FROM qipai_products') && sql.includes('FOR SHARE')) {
|
|
return [[{ id: String(params[1]) }], []];
|
|
}
|
|
if (sql.includes('SELECT id FROM qipai_product_skus') && sql.includes('FOR SHARE')) {
|
|
const skuId = String(params[2]);
|
|
const requiresActive = sql.includes("status = 'ACTIVE'");
|
|
return [state.skus.has(skuId) && !state.archivedSkus.has(skuId)
|
|
&& (!requiresActive || !state.inactiveSkus.has(skuId))
|
|
? [{ id: skuId }] : [], []];
|
|
}
|
|
if (sql.includes('SELECT id FROM qipai_product_inventory')) {
|
|
const found = findStock(String(params[0]), String(params[1]), String(params[2]));
|
|
return [found ? [{ id: found.id }] : [], []];
|
|
}
|
|
if (sql.includes('FROM qipai_product_inventory') && sql.includes('FOR UPDATE')) {
|
|
const skuId = String(params[2]);
|
|
state.lockOrder.push(skuId);
|
|
const found = findStock(String(params[0]), String(params[1]), skuId);
|
|
return [found ? [{ ...found }] : [], []];
|
|
}
|
|
if (sql.includes('FROM qipai_product_inventory_ledger')
|
|
&& sql.includes('request_id = ?')) {
|
|
const row = state.ledgers.find((item) => item.tenantId === String(params[0])
|
|
&& item.inventoryId === String(params[1]) && item.requestId === String(params[2]));
|
|
return [row ? [{ ...row }] : [], []];
|
|
}
|
|
if (sql.includes('AS reservedQuantity') && sql.includes('business_type = ?')) {
|
|
const inventoryIds = new Set(params.slice(4).map(String));
|
|
const balances = new Map();
|
|
for (const item of state.ledgers) {
|
|
if (item.tenantId !== String(params[0]) || item.storeId !== String(params[1])
|
|
|| item.businessType !== String(params[2]) || item.businessId !== String(params[3])
|
|
|| !inventoryIds.has(item.inventoryId)) continue;
|
|
const metadata = JSON.parse(item.metadata);
|
|
const reservationDelta = metadata.inventoryReservationDelta ?? Number(item.lockedDelta);
|
|
balances.set(item.inventoryId,
|
|
(balances.get(item.inventoryId) ?? 0) + Number(reservationDelta));
|
|
}
|
|
return [[...balances.entries()].map(([inventoryId, reservedQuantity]) => ({
|
|
inventoryId, reservedQuantity
|
|
})), []];
|
|
}
|
|
if (sql.includes('AS reservedQuantity')
|
|
&& sql.includes('WHERE tenant_id = ? AND inventory_id = ?')) {
|
|
const reservedQuantity = state.ledgers
|
|
.filter((item) => item.tenantId === String(params[0])
|
|
&& item.inventoryId === String(params[1]))
|
|
.reduce((total, item) => {
|
|
const metadata = JSON.parse(item.metadata);
|
|
return total + Number(metadata.inventoryReservationDelta ?? item.lockedDelta);
|
|
}, 0);
|
|
return [[{ reservedQuantity }], []];
|
|
}
|
|
if (sql.startsWith('UPDATE qipai_product_inventory')) {
|
|
const found = state.stocks.find((item) => item.tenantId === String(params[7])
|
|
&& item.id === String(params[8]) && item.version === Number(params[9]));
|
|
if (!found) return [{ affectedRows: 0 }, []];
|
|
Object.assign(found, {
|
|
policyType: params[0], availableQuantity: Number(params[1]),
|
|
lockedQuantity: Number(params[2]), lossQuantity: Number(params[3]),
|
|
lowStockThreshold: Number(params[4]), version: Number(params[5])
|
|
});
|
|
return [{ affectedRows: 1 }, []];
|
|
}
|
|
if (sql.includes('INSERT INTO qipai_product_inventory_ledger')) {
|
|
const duplicate = state.ledgers.some((item) => item.tenantId === String(params[0])
|
|
&& item.inventoryId === String(params[1]) && item.requestId === String(params[4]));
|
|
if (duplicate) throw new Error('duplicate inventory ledger request');
|
|
const row = {
|
|
id: String(state.nextLedgerId++),
|
|
tenantId: String(params[0]), inventoryId: String(params[1]),
|
|
storeId: String(params[2]), skuId: String(params[3]), requestId: String(params[4]),
|
|
businessType: String(params[5]), businessId: String(params[6]), operation: params[7],
|
|
availableDelta: Number(params[8]), lockedDelta: Number(params[9]),
|
|
lossDelta: Number(params[10]), availableAfter: Number(params[11]),
|
|
lockedAfter: Number(params[12]), lossAfter: Number(params[13]),
|
|
versionAfter: Number(params[14]), operatorId: params[15] == null ? null : String(params[15]),
|
|
traceId: String(params[16]), reason: String(params[17]), metadata: String(params[18]),
|
|
createdAt: new Date()
|
|
};
|
|
state.ledgers.push(row);
|
|
return [{ insertId: row.id, affectedRows: 1 }, []];
|
|
}
|
|
if (sql.includes('INSERT INTO qipai_audit_logs')) {
|
|
state.audits.push({ action: params[3], resourceId: String(params[4]), metadata: params[8] });
|
|
return [{ insertId: state.audits.length, affectedRows: 1 }, []];
|
|
}
|
|
throw new Error(`Unexpected SQL: ${sql}`);
|
|
}
|
|
|
|
function findStock(tenantId, storeId, skuId) {
|
|
return state.stocks.find((item) => item.tenantId === tenantId
|
|
&& item.storeId === storeId && item.skuId === skuId);
|
|
}
|
|
|
|
const manager = {
|
|
tenantId: '7', userId: '21',
|
|
access: { roles: ['STORE_ADMIN'], capabilities: ['inventory.read', 'inventory.adjust'], storeIds: ['11'] },
|
|
traceId: 'inventory-test', ip: '127.0.0.1', userAgent: 'inventory-test-agent'
|
|
};
|
|
const service = new InventoryService(pool);
|
|
|
|
const listed = await service.listStocks(manager, { storeId: '11', page: 1, pageSize: 20 });
|
|
assert.equal(listed.total, 3);
|
|
assert.equal(listed.items[0].tenantId, '7');
|
|
assert.equal(listed.items[0].lossQuantity, 1);
|
|
|
|
const inboundInput = {
|
|
storeId: '11', skuId: '5', requestId: 'admin-inbound-1', reason: '首批入库',
|
|
expectedVersion: 1, quantity: 5
|
|
};
|
|
const inbound = await service.inbound(manager, inboundInput);
|
|
assert.equal(inbound.availableQuantity, 15);
|
|
assert.equal(inbound.version, 2);
|
|
const auditCountAfterInbound = state.audits.length;
|
|
const replay = await service.inbound(manager, inboundInput);
|
|
assert.equal(replay.idempotent, true);
|
|
assert.equal(replay.availableQuantity, 15);
|
|
assert.equal(state.audits.length, auditCountAfterInbound);
|
|
await assert.rejects(
|
|
() => service.inbound(manager, { ...inboundInput, quantity: 6 }),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_IDEMPOTENCY_CONFLICT'
|
|
);
|
|
|
|
const adjusted = await service.adjust(manager, {
|
|
storeId: '11', skuId: '5', requestId: 'admin-adjust-1', reason: '人工纠偏',
|
|
expectedVersion: 2, availableDelta: -2, lossDelta: 1
|
|
});
|
|
assert.deepEqual(
|
|
[adjusted.availableQuantity, adjusted.lossQuantity, adjusted.version],
|
|
[13, 2, 3]
|
|
);
|
|
const counted = await service.stocktake(manager, {
|
|
storeId: '11', skuId: '5', requestId: 'admin-stocktake-1', reason: '闭店盘点',
|
|
expectedVersion: 3, availableQuantity: 12, lossQuantity: 3
|
|
});
|
|
assert.deepEqual(
|
|
[counted.availableQuantity, counted.lossQuantity, counted.version],
|
|
[12, 3, 4]
|
|
);
|
|
const lost = await service.recordLoss(manager, {
|
|
storeId: '11', skuId: '5', requestId: 'admin-loss-1', reason: '包装破损',
|
|
expectedVersion: 4, quantity: 2
|
|
});
|
|
assert.deepEqual([lost.availableQuantity, lost.lossQuantity, lost.version], [10, 5, 5]);
|
|
|
|
const configured = await service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '4', requestId: 'admin-policy-1', reason: '启用库存追踪',
|
|
expectedVersion: 0, policyType: 'TRACKED', lowStockThreshold: 3
|
|
});
|
|
assert.equal(configured.policyType, 'TRACKED');
|
|
assert.equal(configured.lowStockThreshold, 3);
|
|
assert.ok(findStock('7', '11', '4'));
|
|
const reconfigured = await service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '4', requestId: 'admin-policy-2', reason: 'raise warning threshold',
|
|
policyType: 'TRACKED', lowStockThreshold: 7, expectedVersion: 2
|
|
});
|
|
assert.equal(reconfigured.lowStockThreshold, 7);
|
|
const configuredReplay = await service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '4', requestId: 'admin-policy-1', reason: '启用库存追踪',
|
|
expectedVersion: 0, policyType: 'TRACKED', lowStockThreshold: 3
|
|
});
|
|
assert.equal(configuredReplay.idempotent, true);
|
|
assert.equal(configuredReplay.lowStockThreshold, 3);
|
|
await assert.rejects(
|
|
() => service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '5', requestId: 'admin-policy-unlimited', reason: '错误切换',
|
|
policyType: 'UNLIMITED', lowStockThreshold: 0, expectedVersion: 5
|
|
}),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_POLICY_STOCK_NOT_ZERO'
|
|
);
|
|
|
|
const scopedOut = { ...manager, access: { ...manager.access, storeIds: ['12'] } };
|
|
await assert.rejects(
|
|
() => service.listStocks(scopedOut, { storeId: '11', page: 1, pageSize: 20 }),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_STORE_SCOPE_FORBIDDEN'
|
|
);
|
|
|
|
state.lockOrder.length = 0;
|
|
const batchBase = {
|
|
tenantId: '7', storeId: '11', requestId: 'order-lock-1',
|
|
businessType: 'PRODUCT_ORDER', businessId: 'order-500', traceId: 'order-lock-trace',
|
|
operatorId: '21', reason: '创建商品订单', metadata: { source: 'ORDER' },
|
|
items: [{ skuId: '5', quantity: 3 }, { skuId: '2', quantity: 1 }, { skuId: '2', quantity: 1 }]
|
|
};
|
|
const locked = await service.lockMany(batchBase);
|
|
assert.equal(locked.idempotent, false);
|
|
assert.deepEqual(state.lockOrder.slice(-2), ['2', '5']);
|
|
assert.deepEqual(
|
|
[findStock('7', '11', '2').availableQuantity, findStock('7', '11', '2').lockedQuantity],
|
|
[2, 2]
|
|
);
|
|
assert.deepEqual(
|
|
[findStock('7', '11', '5').availableQuantity, findStock('7', '11', '5').lockedQuantity],
|
|
[7, 3]
|
|
);
|
|
const ledgerCountAfterLock = state.ledgers.length;
|
|
const lockedReplay = await service.lockMany(batchBase);
|
|
assert.equal(lockedReplay.idempotent, true);
|
|
assert.equal(state.ledgers.length, ledgerCountAfterLock);
|
|
await assert.rejects(
|
|
() => service.lockMany({ ...batchBase, items: [{ skuId: '5', quantity: 4 }, { skuId: '2', quantity: 2 }] }),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_IDEMPOTENCY_CONFLICT'
|
|
);
|
|
await assert.rejects(
|
|
() => service.lockMany({ ...batchBase, items: [{ skuId: '9', quantity: 1 }] }),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_IDEMPOTENCY_CONFLICT'
|
|
);
|
|
|
|
await assert.rejects(
|
|
() => service.releaseMany({
|
|
...batchBase, requestId: 'foreign-order-release', businessId: 'order-foreign',
|
|
items: [{ skuId: '5', quantity: 1 }]
|
|
}),
|
|
(error) => error instanceof InventoryError
|
|
&& error.code === 'INVENTORY_INSUFFICIENT_RESERVATION'
|
|
);
|
|
|
|
await service.releaseMany({
|
|
...batchBase, requestId: 'order-release-1', reason: '部分取消',
|
|
items: [{ skuId: '5', quantity: 1 }, { skuId: '2', quantity: 1 }]
|
|
});
|
|
await service.deductMany({
|
|
...batchBase, requestId: 'order-deduct-1', reason: '支付确认扣减',
|
|
items: [{ skuId: '5', quantity: 2 }, { skuId: '2', quantity: 1 }]
|
|
});
|
|
assert.deepEqual(
|
|
[findStock('7', '11', '2').availableQuantity, findStock('7', '11', '2').lockedQuantity],
|
|
[3, 0]
|
|
);
|
|
assert.deepEqual(
|
|
[findStock('7', '11', '5').availableQuantity, findStock('7', '11', '5').lockedQuantity],
|
|
[8, 0]
|
|
);
|
|
|
|
const beforeFailedBatch = structuredClone(state.stocks);
|
|
await assert.rejects(
|
|
() => service.lockMany({
|
|
...batchBase, requestId: 'order-lock-too-many', businessId: 'order-501',
|
|
items: [{ skuId: '5', quantity: 999 }]
|
|
}),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_INSUFFICIENT_AVAILABLE'
|
|
);
|
|
assert.deepEqual(state.stocks, beforeFailedBatch);
|
|
assert.ok(state.rollbacks > 0);
|
|
|
|
const unlimited = await service.lockMany({
|
|
...batchBase, requestId: 'order-unlimited-lock', businessId: 'order-502',
|
|
items: [{ skuId: '9', quantity: 999 }]
|
|
});
|
|
assert.equal(unlimited.items[0].availableQuantity, 0);
|
|
assert.equal(unlimited.items[0].lockedQuantity, 0);
|
|
await assert.rejects(
|
|
() => service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '9', requestId: 'unlimited-switch-active', reason: '切换追踪',
|
|
expectedVersion: unlimited.items[0].version, policyType: 'TRACKED', lowStockThreshold: 0
|
|
}),
|
|
(error) => error instanceof InventoryError
|
|
&& error.code === 'INVENTORY_POLICY_HAS_ACTIVE_RESERVATIONS'
|
|
);
|
|
const unlimitedDeduct = await service.deductMany({
|
|
...batchBase, requestId: 'order-unlimited-deduct', businessId: 'order-502',
|
|
items: [{ skuId: '9', quantity: 999 }]
|
|
});
|
|
const trackedAfterUnlimited = await service.configurePolicy(manager, {
|
|
storeId: '11', skuId: '9', requestId: 'unlimited-switch-settled', reason: '切换追踪',
|
|
expectedVersion: unlimitedDeduct.items[0].version,
|
|
policyType: 'TRACKED', lowStockThreshold: 0
|
|
});
|
|
assert.equal(trackedAfterUnlimited.policyType, 'TRACKED');
|
|
|
|
state.inactiveSkus.add('2');
|
|
const inactiveReplay = await service.lockMany(batchBase);
|
|
assert.equal(inactiveReplay.idempotent, true);
|
|
await assert.rejects(
|
|
() => service.lockMany({
|
|
...batchBase, requestId: 'inactive-sku-lock', businessId: 'order-503',
|
|
items: [{ skuId: '2', quantity: 1 }]
|
|
}),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_SKU_NOT_SELLABLE'
|
|
);
|
|
state.inactiveSkus.delete('2');
|
|
|
|
state.archivedSkus.add('5');
|
|
const archivedAdminReplay = await service.inbound(manager, inboundInput);
|
|
assert.equal(archivedAdminReplay.idempotent, true);
|
|
await assert.rejects(
|
|
() => service.inbound(manager, {
|
|
storeId: '11', skuId: '5', requestId: 'archived-sku-inbound',
|
|
reason: '归档规格不得重新入库', quantity: 1
|
|
}),
|
|
(error) => error instanceof InventoryError && error.code === 'INVENTORY_SKU_NOT_FOUND'
|
|
);
|
|
state.archivedSkus.delete('5');
|
|
|
|
const history = await service.listLedger(manager, {
|
|
storeId: '11', inventoryId: '101', page: 1, pageSize: 100
|
|
});
|
|
assert.ok(history.items.length >= 7);
|
|
assert.ok(history.items.every((item) => item.metadata.idempotencyFingerprint));
|
|
assert.equal(state.audits.length, state.ledgers.length);
|
|
|
|
console.log('PASS: M09-D1 inventory policy, inbound/adjust/stocktake/loss, ordered batch locks, idempotency, immutable ledger, scope and audit work.');
|