220 lines
8.9 KiB
TypeScript
220 lines
8.9 KiB
TypeScript
/**
|
|
* 履约路由状态机集成测试(需要真实 PostgreSQL)。
|
|
*
|
|
* 运行:
|
|
* FULFILLMENT_ROUTING_TEST_DATABASE_URL="$DATABASE_URL" \
|
|
* npx tsx --test src/services/fulfillment/fulfillment-routing.integration.test.ts
|
|
*
|
|
* 未设置环境变量时跳过,普通 npm test 不依赖数据库。
|
|
*/
|
|
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
|
|
const TEST_DATABASE_URL = String(process.env.FULFILLMENT_ROUTING_TEST_DATABASE_URL || '').trim()
|
|
|
|
test(
|
|
'运营指定渠道:先保证载体;支持安全切换;缺载体保持 pending',
|
|
{ skip: !TEST_DATABASE_URL ? '未设置 FULFILLMENT_ROUTING_TEST_DATABASE_URL' : false },
|
|
async () => {
|
|
process.env.DATABASE_URL = TEST_DATABASE_URL
|
|
const { closeDb, query } = await import('../../db/client.js')
|
|
const {
|
|
assignChannelByInternalSku,
|
|
deleteChannelRule,
|
|
ensureVoucherRuleForSku,
|
|
listChannelRules,
|
|
switchChannelForOrderItems,
|
|
upsertChannelRule,
|
|
} = await import('./channel-assign-service.js')
|
|
const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}`
|
|
const shopId = `it-routing-${suffix}`
|
|
const manualSku = `集成测试人工-${suffix}`
|
|
const missingAffiliateSku = `集成测试自动-${suffix}`
|
|
const voucherSku = `集成测试卡券-${suffix}`
|
|
const orderIds: number[] = []
|
|
const orderItemIds: number[] = []
|
|
const internalSkus = [manualSku, missingAffiliateSku, voucherSku]
|
|
let generatedVoucherProductId: number | null = null
|
|
|
|
async function createPendingOrderItem(sku: string) {
|
|
const order = await query<{ id: number }>(
|
|
`INSERT INTO orders (
|
|
provider, platform, shop_id, platform_order_id, order_status, pay_status,
|
|
total_amount, paid_at, created_at, updated_at
|
|
) VALUES (
|
|
'91kaquan', 'kuaishou-91', $1, $2, 'paid', 'paid', 1000, NOW(), NOW(), NOW()
|
|
) RETURNING id`,
|
|
[shopId, `IT-ROUTING-${suffix}-${orderItemIds.length + 1}`],
|
|
)
|
|
const orderId = Number(order.rows[0]!.id)
|
|
orderIds.push(orderId)
|
|
const item = await query<{ id: number }>(
|
|
`INSERT INTO order_items (
|
|
order_id, sku_code, sku_name, quantity, spec_json,
|
|
revenue_amount_fen, revenue_basis, created_at, updated_at
|
|
) VALUES ($1, $2, $2, 1, $3::jsonb, 1000, 'order_total', NOW(), NOW())
|
|
RETURNING id`,
|
|
[orderId, sku, JSON.stringify({ skuNick: sku })],
|
|
)
|
|
const orderItemId = Number(item.rows[0]!.id)
|
|
orderItemIds.push(orderItemId)
|
|
return orderItemId
|
|
}
|
|
|
|
try {
|
|
const manualItemId = await createPendingOrderItem(manualSku)
|
|
await query(
|
|
`INSERT INTO manual_fulfillment_configs (
|
|
sku_key, platform_key, credit_quantity, cost_mode, enabled, note, created_at, updated_at
|
|
) VALUES ($1, 'nanhang', 0, 'variable', TRUE, '集成测试', NOW(), NOW())`,
|
|
[manualSku],
|
|
)
|
|
|
|
const manualAssigned = await assignChannelByInternalSku({
|
|
provider: '91kaquan',
|
|
shopId,
|
|
internalSku: manualSku,
|
|
channel: 'manual',
|
|
adminUserId: null,
|
|
note: '集成测试人工',
|
|
})
|
|
assert.equal(manualAssigned.updated, 1)
|
|
assert.equal(manualAssigned.carrierFailed, 0)
|
|
const manualItem = await query<{
|
|
fulfillment_status: string
|
|
fulfillment_channel: string
|
|
fulfillment_config_id: number | null
|
|
}>(
|
|
`SELECT fulfillment_status, fulfillment_channel, fulfillment_config_id
|
|
FROM order_items WHERE id = $1`,
|
|
[manualItemId],
|
|
)
|
|
assert.equal(manualItem.rows[0]?.fulfillment_status, 'assigned')
|
|
assert.equal(manualItem.rows[0]?.fulfillment_channel, 'manual')
|
|
assert.ok(Number(manualItem.rows[0]?.fulfillment_config_id) > 0)
|
|
|
|
const switched = await switchChannelForOrderItems({
|
|
orderItemIds: [manualItemId],
|
|
channel: 'third_party_voucher',
|
|
adminUserId: null,
|
|
note: '集成测试切换',
|
|
})
|
|
assert.equal(switched.switched, 1)
|
|
assert.equal(switched.failed, 0)
|
|
const switchedItem = await query<{
|
|
fulfillment_status: string
|
|
fulfillment_channel: string
|
|
original_channel: string | null
|
|
canonical_product_id: number | null
|
|
canonical_sku: string | null
|
|
}>(
|
|
`SELECT oi.fulfillment_status, oi.fulfillment_channel, oi.original_channel,
|
|
oi.canonical_product_id, product.canonical_sku
|
|
FROM order_items oi
|
|
LEFT JOIN product_catalog product ON product.id = oi.canonical_product_id
|
|
WHERE oi.id = $1`,
|
|
[manualItemId],
|
|
)
|
|
assert.equal(switchedItem.rows[0]?.fulfillment_status, 'assigned')
|
|
assert.equal(switchedItem.rows[0]?.fulfillment_channel, 'third_party_voucher')
|
|
assert.equal(switchedItem.rows[0]?.original_channel, 'manual')
|
|
assert.ok(switchedItem.rows[0]?.canonical_sku?.startsWith('tpv:'))
|
|
generatedVoucherProductId = Number(switchedItem.rows[0]?.canonical_product_id || 0) || null
|
|
|
|
const missingAffiliateItemId = await createPendingOrderItem(missingAffiliateSku)
|
|
const affiliateFailed = await assignChannelByInternalSku({
|
|
provider: '91kaquan',
|
|
shopId,
|
|
internalSku: missingAffiliateSku,
|
|
channel: 'affiliate_dash',
|
|
adminUserId: null,
|
|
note: '集成测试缺映射',
|
|
})
|
|
assert.equal(affiliateFailed.updated, 0)
|
|
assert.equal(affiliateFailed.carrierFailed, 1)
|
|
const pendingItem = await query<{
|
|
fulfillment_status: string
|
|
fulfillment_channel: string | null
|
|
fulfillment_pending_reason: string | null
|
|
}>(
|
|
`SELECT fulfillment_status, fulfillment_channel, fulfillment_pending_reason
|
|
FROM order_items WHERE id = $1`,
|
|
[missingAffiliateItemId],
|
|
)
|
|
assert.equal(pendingItem.rows[0]?.fulfillment_status, 'pending')
|
|
assert.equal(pendingItem.rows[0]?.fulfillment_channel, null)
|
|
assert.equal(pendingItem.rows[0]?.fulfillment_pending_reason, 'no_carrier')
|
|
|
|
await ensureVoucherRuleForSku(voucherSku)
|
|
const voucherChannel = await query<{ channel: string; source: string }>(
|
|
`SELECT channel, source FROM internal_sku_channels
|
|
WHERE internal_sku = $1 ORDER BY channel`,
|
|
[voucherSku],
|
|
)
|
|
assert.deepEqual(voucherChannel.rows, [{ channel: 'third_party_voucher', source: 'voucher' }])
|
|
const legacyVoucherRules = await query<{ count: number }>(
|
|
`SELECT count(*)::int AS count FROM sku_channel_rules
|
|
WHERE match_key = $1`,
|
|
[voucherSku],
|
|
)
|
|
assert.equal(legacyVoucherRules.rows[0]?.count, 0)
|
|
const savedRule = await upsertChannelRule({
|
|
matchKeyType: 'internal_sku',
|
|
matchKey: voucherSku,
|
|
channel: 'third_party_voucher',
|
|
priority: 10,
|
|
enabled: true,
|
|
note: '集成测试统一渠道',
|
|
adminUserId: null,
|
|
})
|
|
const listedRules = await listChannelRules({ channel: 'third_party_voucher', enabled: true })
|
|
assert.ok(
|
|
listedRules.some((rule) => rule.id === savedRule.id && rule.match_key === voucherSku),
|
|
)
|
|
assert.equal((await deleteChannelRule(savedRule.id)).deleted, true)
|
|
} finally {
|
|
if (orderItemIds.length > 0) {
|
|
await query(`DELETE FROM cost_exception_items WHERE order_item_id = ANY($1::bigint[])`, [
|
|
orderItemIds,
|
|
])
|
|
await query(`DELETE FROM cost_snapshots WHERE order_item_id = ANY($1::bigint[])`, [
|
|
orderItemIds,
|
|
])
|
|
await query(`DELETE FROM order_items WHERE id = ANY($1::bigint[])`, [orderItemIds])
|
|
}
|
|
if (orderIds.length > 0) {
|
|
await query(`DELETE FROM orders WHERE id = ANY($1::bigint[])`, [orderIds])
|
|
}
|
|
await query(`DELETE FROM cost_exceptions WHERE scope_key LIKE $1`, [`%${suffix}%`])
|
|
await query(`DELETE FROM manual_fulfillment_configs WHERE sku_key = $1`, [manualSku])
|
|
await query(`DELETE FROM internal_sku_channels WHERE internal_sku = ANY($1::text[])`, [
|
|
internalSkus,
|
|
])
|
|
await query(
|
|
`DELETE FROM sku_channel_rules
|
|
WHERE provider = '91kaquan' AND shop_id = $1 AND match_key = ANY($2::text[])`,
|
|
[shopId, internalSkus],
|
|
)
|
|
if (generatedVoucherProductId) {
|
|
await query(`DELETE FROM sales_daily_facts WHERE canonical_product_id = $1`, [
|
|
generatedVoucherProductId,
|
|
])
|
|
await query(`DELETE FROM cost_snapshots WHERE canonical_product_id = $1`, [
|
|
generatedVoucherProductId,
|
|
])
|
|
await query(`DELETE FROM channel_product_mappings WHERE canonical_product_id = $1`, [
|
|
generatedVoucherProductId,
|
|
])
|
|
await query(`DELETE FROM cost_versions WHERE canonical_product_id = $1`, [
|
|
generatedVoucherProductId,
|
|
])
|
|
await query(`DELETE FROM product_catalog WHERE id = $1 AND canonical_sku = $2`, [
|
|
generatedVoucherProductId,
|
|
`tpv:${manualSku}`,
|
|
])
|
|
}
|
|
await closeDb()
|
|
}
|
|
},
|
|
)
|