/** * 履约路由状态机集成测试(需要真实 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 { assignPendingOrderItemChannels, assignChannelByInternalSku, deletePendingChannelGroup, deleteChannelRules, ensureVoucherRuleForSku, forceDeleteChannelRules, listChannelRules, listChannelRulesPage, listPendingChannelGroups, retryPendingCarrierGroup, switchChannelForOrderItems, unlockPendingChannelGroup, upsertChannelRule, } = await import('./channel-assign-service.js') const { deleteManualSkuClassification, saveManualFulfillmentConfig } = await import('../cost-center/manual-fulfillment-config-service.js') const { runAffiliateFallback } = await import('./affiliate-fallback-service.js') const { getFulfillmentAutomationCutoff } = await import('./fulfillment-automation-config-service.js') const { reconcilePendingCarriers } = await import('./carrier-reconciliation-service.js') const { retryPendingWorkOrderRouting } = await import('./pending-channel-repair-service.js') const { deleteInternalSkuMapping, listInternalSkuMappingsPage, resolveInternalSkuMapping, upsertInternalSkuMapping, } = await import('./internal-sku-mapping-service.js') const { resolveOrderItemForFulfillment } = await import('./product-resolution-service.js') const { updateOrderItemSourceSnapshot } = await import('../../repositories/order-item-repo.js') const { listTasks } = await import('../../repositories/task-repo.js') const { listVoucherConsumeJobs } = await import('./voucher-consume-queue-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 triggerSku = `集成测试规范-${suffix}` const fallbackSku = `集成测试兜底-${suffix}` const autoManualSku = `集成测试自动人工-${suffix}` const retryWorkOrderSku = `集成测试重试接单-${suffix}` const manualRemoveSku = `集成测试移除人工-${suffix}` const protectedRuleSku = `集成测试强制删除-${suffix}` const missingVoucherSku = `集成测试无商品卡券-${suffix}` const reactivatedVoucherSku = `集成测试归档卡券-${suffix}` const retryPendingAffiliateSku = `集成测试失败待重试-${suffix}` const cutoffTestSku = `集成测试自动化边界-${suffix}` const retryWorkOrderRuleKey = `it-retry-${suffix}` const orderIds: number[] = [] const orderItemIds: number[] = [] const crossShopSku = `集成测试跨店-${suffix}` const internalSkus = [ manualSku, missingAffiliateSku, voucherSku, crossShopSku, triggerSku, fallbackSku, autoManualSku, retryWorkOrderSku, manualRemoveSku, protectedRuleSku, missingVoucherSku, reactivatedVoucherSku, retryPendingAffiliateSku, cutoffTestSku, ] const createdVoucherProductIds: number[] = [] let autoManualProductId: number | null = null let retryWorkOrderRuleId: number | null = null let fallbackProfileId: number | null = null async function createPendingOrderItem( sku: string, options: { provider?: string; platform?: string; shopId?: string; shopName?: string } = {}, ) { const provider = options.provider || '91kaquan' const platform = options.platform || 'kuaishou-91' const targetShopId = options.shopId || shopId const targetShopName = options.shopName || '' const order = await query<{ id: number }>( `INSERT INTO orders ( provider, platform, shop_id, shop_name, platform_order_id, order_status, pay_status, total_amount, paid_at, created_at, updated_at ) VALUES ( $1, $2, $3, $4, $5, 'paid', 'paid', 1000, NOW(), NOW(), NOW() ) RETURNING id`, [ provider, platform, targetShopId, targetShopName, `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 } async function setRoute(input: { sku: string channel: string priority?: number role?: 'primary' | 'fallback' configJson?: Record source?: string }) { const sku = await query<{ id: string }>('SELECT ensure_canonical_internal_sku($1) AS id', [ input.sku, ]) const internalSkuId = Number(sku.rows[0]!.id) const role = input.role || 'primary' if (role === 'primary') { await query( `UPDATE sku_channel_routes SET route_role = 'fallback', priority = GREATEST(priority, 90), updated_at = NOW() WHERE internal_sku_id = $1 AND channel <> $2 AND enabled = TRUE AND route_role = 'primary'`, [internalSkuId, input.channel], ) } const route = await query<{ id: number }>( ` INSERT INTO sku_channel_routes ( internal_sku_id, channel, route_role, priority, enabled, carrier_config_json, source ) VALUES ($1, $2, $3, $4, TRUE, $5::jsonb, $6) ON CONFLICT (internal_sku_id, channel) DO UPDATE SET route_role = EXCLUDED.route_role, priority = EXCLUDED.priority, enabled = TRUE, carrier_config_json = EXCLUDED.carrier_config_json, source = EXCLUDED.source, updated_at = NOW() RETURNING id `, [ internalSkuId, input.channel, role, input.priority ?? (role === 'primary' ? 10 : 90), JSON.stringify(input.configJson || {}), input.source || 'integration_test', ], ) return Number(route.rows[0]!.id) } try { const canonicalResolution = await query<{ internal_sku: string | null platform_only: string | null cjk_extension: string | null case_variant: string | null }>( `SELECT resolve_internal_sku('platform-code', ' 套装-浪漫 天命 ', 'platform-code') AS internal_sku, resolve_internal_sku('platform-code', 'Platform Title', 'platform-code') AS platform_only, resolve_internal_sku('', '𠀀', '') AS cjk_extension, resolve_internal_sku('', '黑色ROCK长袖T恤', '') AS case_variant`, ) assert.equal(canonicalResolution.rows[0]?.internal_sku, '套装-浪漫天命') assert.equal(canonicalResolution.rows[0]?.platform_only, null) assert.equal(canonicalResolution.rows[0]?.cjk_extension, '𠀀') assert.equal(canonicalResolution.rows[0]?.case_variant, '黑色rock长袖t恤') assert.ok(Number.isFinite(Date.parse(await getFulfillmentAutomationCutoff()))) const cutoffNewItemId = await createPendingOrderItem(cutoffTestSku) const cutoffOldItemId = await createPendingOrderItem(cutoffTestSku) await query( `UPDATE orders SET created_at = '2019-01-01T00:00:00+08:00', updated_at = '2019-01-01T00:00:00+08:00' WHERE id = (SELECT order_id FROM v_order_item_current WHERE id = $1)`, [cutoffOldItemId], ) await setRoute({ sku: cutoffTestSku, channel: 'third_party_voucher' }) const cutoffAssignment = await assignPendingOrderItemChannels({ orderItemIds: [cutoffOldItemId, cutoffNewItemId], batchSize: 10, maxBatches: 1, cutoffCreatedAt: '2020-01-01T00:00:00+08:00', }) assert.equal(cutoffAssignment.scanned, 1) assert.equal(cutoffAssignment.assigned, 1) const cutoffStates = await query<{ id: number; fulfillment_status: string }>( `SELECT id, fulfillment_status FROM v_order_item_current WHERE id = ANY($1::bigint[]) ORDER BY id DESC`, [[cutoffOldItemId, cutoffNewItemId]], ) assert.equal(cutoffStates.rows[0]?.fulfillment_status, 'pending') assert.equal(cutoffStates.rows[1]?.fulfillment_status, 'assigned') await setRoute({ sku: ` 集成测试 规范-${suffix} `, channel: 'manual', role: 'fallback', }) const normalizedInsert = await query<{ internal_sku: string }>( `SELECT sku.internal_sku_key AS internal_sku FROM sku_channel_routes route JOIN internal_skus sku ON sku.id = route.internal_sku_id WHERE route.source = 'integration_test' AND sku.internal_sku_key = canonicalize_internal_sku($1) ORDER BY route.id DESC LIMIT 1`, [triggerSku], ) assert.equal(normalizedInsert.rows[0]?.internal_sku, triggerSku) const mappingValue = `MAP-${suffix}` const mappingSku = `集成映射-${suffix}` const mappingId = await upsertInternalSkuMapping({ provider: '91kaquan', shopId, matchType: 'sku_code', matchValue: ` ${mappingValue} `, internalSku: mappingSku, priority: 10, source: 'integration_test', note: '集成测试映射', }) const resolvedMapping = await resolveInternalSkuMapping({ provider: '91kaquan', shopId, candidates: [{ matchType: 'sku_code', value: mappingValue }], }) assert.equal(resolvedMapping?.internalSku, mappingSku) const resolvedLongTitleItem = await resolveOrderItemForFulfillment({ provider: '91kaquan', shopId, item: { externalItemId: `mapping-item-${suffix}`, externalSkuCode: mappingValue, externalSkuName: '平台长中文商品标题(不应成为内部 SKU)', skuCode: mappingValue, skuName: '平台长中文商品标题(不应成为内部 SKU)', quantity: 1, }, }) assert.equal(resolvedLongTitleItem.snapshot.internalSku, mappingSku) assert.equal(resolvedLongTitleItem.skuName, mappingSku) const mappingPage = await listInternalSkuMappingsPage({ keyword: mappingSku, page: 1, pageSize: 10, }) assert.equal(mappingPage.total, 1) assert.equal(await deleteInternalSkuMapping(mappingId), true) 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({ 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 v_order_item_current 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 sourceSyncedItem = await updateOrderItemSourceSnapshot(manualItemId, { skuName: `平台覆盖-${suffix}`, specJson: JSON.stringify({ skuNick: `平台覆盖-${suffix}` }), itemSnapshotJson: JSON.stringify({ externalSkuName: `平台覆盖-${suffix}` }), updatedAt: new Date().toISOString(), }) assert.equal(sourceSyncedItem?.sku_name, manualSku) assert.equal(sourceSyncedItem?.spec_json?.skuNick, manualSku) 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 item_snapshot_json: Record }>( `SELECT oi.fulfillment_status, oi.fulfillment_channel, oi.original_channel, oi.canonical_product_id, product.canonical_sku, oi.item_snapshot_json FROM v_order_item_current 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:')) assert.equal( switchedItem.rows[0]?.item_snapshot_json.internalSkuChannel, 'third_party_voucher', ) assert.equal(switchedItem.rows[0]?.item_snapshot_json.isConfigured, false) const missingAffiliateItemId = await createPendingOrderItem(missingAffiliateSku) const affiliateFailed = await assignChannelByInternalSku({ 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 v_order_item_current 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') const autoManualItemId = await createPendingOrderItem(autoManualSku) const missingManual = await assignChannelByInternalSku({ internalSku: autoManualSku, channel: 'manual', adminUserId: null, note: '集成测试缺人工配置', }) assert.equal(missingManual.updated, 0) assert.equal(missingManual.carrierFailed, 1) const savedManual = await saveManualFulfillmentConfig({ skuKey: autoManualSku, platformKey: 'fund_cash', creditQuantity: 69, note: '集成测试一次配置', }) autoManualProductId = Number(savedManual.canonicalProductId || 0) || null assert.ok(autoManualProductId) assert.ok(savedManual.syncSummary.pendingAssigned >= 1) const autoManualItem = await query<{ fulfillment_status: string fulfillment_channel: string fulfillment_config_id: number | null canonical_product_id: number | null }>( `SELECT fulfillment_status, fulfillment_channel, fulfillment_config_id, canonical_product_id FROM v_order_item_current WHERE id = $1`, [autoManualItemId], ) assert.equal(autoManualItem.rows[0]?.fulfillment_status, 'assigned') assert.equal(autoManualItem.rows[0]?.fulfillment_channel, 'manual') assert.ok(Number(autoManualItem.rows[0]?.fulfillment_config_id) > 0) assert.equal(Number(autoManualItem.rows[0]?.canonical_product_id), autoManualProductId) const retryWorkOrderItemId = await createPendingOrderItem(retryWorkOrderSku, { provider: 'douyin_mashida', platform: 'doudian', shopId: '305760014', }) const retryRule = await query<{ id: number }>( `INSERT INTO work_product_rules ( rule_key, provider, platform, shop_id, sku_code, product_name, match_type, category_id, enabled, auto_create, reward_amount, requirement_json, sort_order, created_at, updated_at, pricing_mode ) VALUES ( $1, '', '', '', '', $2, 'exact', NULL, TRUE, TRUE, 1000, '{}'::jsonb, 1, NOW(), NOW(), 'fixed' ) RETURNING id`, [retryWorkOrderRuleKey, retryWorkOrderSku], ) retryWorkOrderRuleId = Number(retryRule.rows[0]?.id || 0) await query( `INSERT INTO work_product_rule_mappings ( rule_id, seller_ids_json, rel_item_id, item_title, rel_sku_id, sku_nick, mapping_type, enabled, created_at, updated_at, sku_match_mode ) VALUES ( $1, '["305760014"]'::jsonb, '', '', '', $2, 'sku_exact', TRUE, NOW(), NOW(), 'exact' )`, [retryWorkOrderRuleId, retryWorkOrderSku], ) await setRoute({ sku: retryWorkOrderSku, channel: 'work_order', configJson: { workRuleKey: retryWorkOrderRuleKey }, }) const retriedWorkOrders = await retryPendingWorkOrderRouting({ internalSku: retryWorkOrderSku, }) assert.equal(retriedWorkOrders.scanned, 1) assert.equal(retriedWorkOrders.createdWorkOrders, 1) assert.equal(retriedWorkOrders.assigned, 1) assert.equal(retriedWorkOrders.remaining, 0) const retriedItem = await query<{ fulfillment_status: string fulfillment_channel: string work_rule_key: string | null }>( `SELECT oi.fulfillment_status, oi.fulfillment_channel, wpr.rule_key AS work_rule_key FROM v_order_item_current oi LEFT JOIN work_orders wo ON wo.order_item_id = oi.id LEFT JOIN work_product_rules wpr ON wpr.id = wo.product_rule_id WHERE oi.id = $1`, [retryWorkOrderItemId], ) assert.equal(retriedItem.rows[0]?.fulfillment_status, 'assigned') assert.equal(retriedItem.rows[0]?.fulfillment_channel, 'work_order') assert.equal(retriedItem.rows[0]?.work_rule_key, retryWorkOrderRuleKey) await query( `UPDATE work_orders SET status = 'cancelled', updated_at = NOW() WHERE order_item_id = $1`, [retryWorkOrderItemId], ) await query( `UPDATE fulfillments SET status = 'pending', channel = NULL, source = 'auto_mapping', pending_reason = 'no_carrier', pending_detail = $2::jsonb, updated_at = NOW() WHERE order_item_id = $1`, [ retryWorkOrderItemId, JSON.stringify({ carrierIssue: 'carrier_task_closed', channel: 'work_order' }), ], ) const retriedCarrier = await retryPendingCarrierGroup({ internalSku: retryWorkOrderSku, retryInactiveCarrier: true, }) assert.equal(retriedCarrier.scanned, 1) assert.equal(retriedCarrier.assigned, 1) assert.equal(retriedCarrier.remaining, 0) const activeWorkOrders = await query<{ count: number }>( `SELECT count(*)::int AS count FROM work_orders WHERE order_item_id = $1 AND status <> 'cancelled'`, [retryWorkOrderItemId], ) assert.equal(activeWorkOrders.rows[0]?.count, 1) const crossShopA = `it-routing-a-${suffix}` const crossShopB = `it-routing-b-${suffix}` await createPendingOrderItem(crossShopSku, { shopId: crossShopA, shopName: '测试店铺 A', }) await createPendingOrderItem(crossShopSku, { provider: 'pdd', platform: 'pdd', shopId: crossShopB, shopName: '测试店铺 B', }) const pendingGroups = await listPendingChannelGroups({ keyword: crossShopSku, page: 1, pageSize: 10, }) assert.equal(pendingGroups.total, 1) assert.equal(pendingGroups.items[0]?.internal_sku, crossShopSku) assert.equal(pendingGroups.items[0]?.item_count, 2) assert.deepEqual(pendingGroups.items[0]?.providers.sort(), ['91kaquan', 'pdd']) assert.deepEqual(pendingGroups.items[0]?.shop_ids.sort(), [crossShopA, crossShopB]) assert.deepEqual( pendingGroups.items[0]?.shops.sort((left, right) => left.id.localeCompare(right.id)), [ { id: crossShopA, name: '测试店铺 A' }, { id: crossShopB, name: '测试店铺 B' }, ], ) const pendingClassification = await listPendingChannelGroups({ keyword: crossShopSku, issueCategory: 'classification', page: 1, pageSize: 10, }) assert.equal(pendingClassification.total, 1) assert.equal( pendingClassification.items[0]?.issue_breakdown[0]?.issue_code, 'missing_channel', ) const pendingAfterSales = await listPendingChannelGroups({ keyword: crossShopSku, issueCategory: 'after_sales', page: 1, pageSize: 10, }) assert.equal(pendingAfterSales.total, 0) const deletedPending = await deletePendingChannelGroup({ internalSku: crossShopSku, adminUserId: null, }) assert.equal(deletedPending.archivedItems, 2) assert.equal(deletedPending.preservedOrders, 2) assert.equal( ( await listPendingChannelGroups({ keyword: crossShopSku, page: 1, pageSize: 10, }) ).total, 0, ) const preservedOrders = await query<{ count: number }>( `SELECT COUNT(*)::int AS count FROM orders WHERE id = ANY($1::bigint[])`, [orderIds], ) assert.ok(preservedOrders.rows[0].count >= 2) const manualRemoveItemId = await createPendingOrderItem(manualRemoveSku, { shopId: crossShopA, shopName: '测试店铺 A', }) await query( `UPDATE fulfillments SET status = 'assigned', channel = 'manual', source = 'carrier_evidence', fulfillment_config_id = NULL, updated_at = NOW() WHERE order_item_id = $1`, [manualRemoveItemId], ) await query( `INSERT INTO manual_sku_registry ( sku_key, display_name, shop_count, order_count, item_count, revenue_fen, first_seen_date, last_seen_date, scan_from_date, scan_to_date, created_at, updated_at ) VALUES ($1, $1, 1, 1, 1, 1000, CURRENT_DATE, CURRENT_DATE, CURRENT_DATE, CURRENT_DATE, NOW(), NOW())`, [manualRemoveSku], ) await setRoute({ sku: manualRemoveSku, channel: 'manual', role: 'fallback', source: 'manual_config', }) const deletedManual = await deleteManualSkuClassification(manualRemoveSku) assert.equal(deletedManual.affectedItems, 1) assert.equal(deletedManual.deletedRegistry, 1) assert.equal(deletedManual.deletedRules, 1) const removedManualItem = await query<{ fulfillment_status: string fulfillment_channel: string | null }>(`SELECT fulfillment_status, fulfillment_channel FROM v_order_item_current WHERE id = $1`, [ manualRemoveItemId, ]) assert.equal(removedManualItem.rows[0]?.fulfillment_status, 'pending') assert.equal(removedManualItem.rows[0]?.fulfillment_channel, null) const protectedRuleId = await setRoute({ sku: protectedRuleSku, channel: 'manual', priority: 70, source: 'manual_config', }) await assert.rejects(() => deleteChannelRules([protectedRuleId]), /不能在渠道页直接删除/) const forcedDeleted = await forceDeleteChannelRules([protectedRuleId]) assert.equal(forcedDeleted.deletedCount, 1) assert.deepEqual(forcedDeleted.deletedIds, [protectedRuleId]) const fallbackItemId = await createPendingOrderItem(fallbackSku) await setRoute({ sku: fallbackSku, channel: 'affiliate_dash' }) await setRoute({ sku: fallbackSku, channel: 'manual', role: 'fallback' }) const fallbackItem = await query<{ order_id: number }>( `UPDATE fulfillments SET status = 'assigned', channel = 'affiliate_dash', source = 'operator_assigned', locked = FALSE, updated_at = NOW() WHERE order_item_id = $1 RETURNING order_id`, [fallbackItemId], ) const fallbackOrderId = Number(fallbackItem.rows[0]!.order_id) const fallbackProfile = await query<{ id: number }>( `INSERT INTO fulfillment_profiles ( profile_key, name, executor_key, requires_claim, auto_dispatch, inventory_strategy, config_json, created_at, updated_at ) VALUES ($1, '集成测试自动发货', 'affiliate_dash', TRUE, FALSE, 'static_pool', '{}'::jsonb, NOW(), NOW()) RETURNING id`, [`it-affiliate-${suffix}`], ) fallbackProfileId = Number(fallbackProfile.rows[0]!.id) const fallbackOrder = await query<{ provider: string platform: string shop_id: string shop_name: string platform_order_id: string }>( `SELECT provider, platform, shop_id, shop_name, platform_order_id FROM orders WHERE id = $1`, [fallbackOrderId], ) const orderRow = fallbackOrder.rows[0]! await query( `INSERT INTO fulfillment_tasks ( order_id, order_item_id, unit_index, task_no, provider, platform, shop_id, shop_name, platform_order_id, profile_id, executor_key, task_status, created_at, updated_at ) VALUES ($1, $2, 1, $3, $4, $5, $6, $7, $8, $9, 'affiliate_dash', 'failed', NOW(), NOW())`, [ fallbackOrderId, fallbackItemId, `IT-AFF-FAIL-${suffix}`, orderRow.provider, orderRow.platform, orderRow.shop_id, orderRow.shop_name, orderRow.platform_order_id, fallbackProfileId, ], ) const fallbackWithoutConfig = await runAffiliateFallback({ limit: 50 }) assert.equal(fallbackWithoutConfig.switched, 0) assert.equal( ( await query<{ fulfillment_channel: string }>( `SELECT fulfillment_channel FROM v_order_item_current WHERE id = $1`, [fallbackItemId], ) ).rows[0]?.fulfillment_channel, 'affiliate_dash', ) const manualFallbackConfig = await query<{ id: number }>( `INSERT INTO manual_fulfillment_configs ( sku_key, platform_key, credit_quantity, cost_mode, enabled, created_at, updated_at ) VALUES ($1, 'nanhang', 0, 'variable', TRUE, NOW(), NOW()) RETURNING id`, [fallbackSku], ) const fallbackWithConfig = await runAffiliateFallback({ limit: 50 }) assert.equal(fallbackWithConfig.switched, 1) const fallbackAssigned = await query<{ fulfillment_channel: string fulfillment_config_id: number | null item_snapshot_json: Record }>( `SELECT fulfillment_channel, fulfillment_config_id, item_snapshot_json FROM v_order_item_current WHERE id = $1`, [fallbackItemId], ) assert.equal(fallbackAssigned.rows[0]?.fulfillment_channel, 'manual') assert.equal(fallbackAssigned.rows[0]?.item_snapshot_json.internalSkuChannel, 'manual') assert.equal(fallbackAssigned.rows[0]?.item_snapshot_json.isConfigured, true) assert.equal( Number(fallbackAssigned.rows[0]?.fulfillment_config_id), Number(manualFallbackConfig.rows[0]!.id), ) const retryTaskItemId = await createPendingOrderItem(autoManualSku) const retryTaskOrder = await query<{ order_id: number provider: string platform: string shop_id: string shop_name: string platform_order_id: string }>( `SELECT oi.order_id, o.provider, o.platform, o.shop_id, o.shop_name, o.platform_order_id FROM v_order_item_current oi JOIN orders o ON o.id = oi.order_id WHERE oi.id = $1`, [retryTaskItemId], ) const retryTaskOrderRow = retryTaskOrder.rows[0]! const insertRetryTask = ( taskNo: string, status: string, attemptNo: number, isCurrent: boolean, ) => query( `INSERT INTO fulfillment_tasks ( order_id, order_item_id, unit_index, task_no, provider, platform, shop_id, shop_name, platform_order_id, profile_id, executor_key, task_status, attempt_no, is_current, created_at, updated_at ) VALUES ( $1, $2, 1, $3, $4, $5, $6, $7, $8, $9, 'affiliate_dash', $10, $11, $12, NOW(), NOW() )`, [ retryTaskOrderRow.order_id, retryTaskItemId, taskNo, retryTaskOrderRow.provider, retryTaskOrderRow.platform, retryTaskOrderRow.shop_id, retryTaskOrderRow.shop_name, retryTaskOrderRow.platform_order_id, fallbackProfileId, status, attemptNo, isCurrent, ], ) await insertRetryTask(`IT-AFF-CLOSED-${suffix}`, 'closed', 1, false) await insertRetryTask(`IT-AFF-ACTIVE-${suffix}`, 'paid', 2, true) await assert.rejects( () => insertRetryTask(`IT-AFF-DUPLICATE-${suffix}`, 'claimed', 3, false), /duplicate key value violates unique constraint/, ) const retryTaskRows = await query<{ task_status: string }>( `SELECT task_status FROM fulfillment_tasks WHERE order_item_id = $1 ORDER BY id`, [retryTaskItemId], ) assert.deepEqual( retryTaskRows.rows.map((row) => row.task_status), ['closed', 'paid'], ) const currentTasksOnly = await listTasks({ platformOrderId: retryTaskOrderRow.platform_order_id, currentOnly: true, page: 1, pageSize: 20, }) assert.equal(currentTasksOnly.total, 1) assert.equal(currentTasksOnly.items[0]?.task_status, 'paid') const allTaskAttempts = await listTasks({ platformOrderId: retryTaskOrderRow.platform_order_id, currentOnly: false, page: 1, pageSize: 20, }) assert.equal(allTaskAttempts.total, 2) assert.equal(await ensureVoucherRuleForSku(missingVoucherSku), false) const missingVoucherRules = await query<{ count: number }>( `SELECT count(*)::int AS count FROM sku_channel_routes route JOIN internal_skus sku ON sku.id = route.internal_sku_id WHERE sku.internal_sku_key = $1 AND route.channel = 'third_party_voucher'`, [missingVoucherSku], ) assert.equal(missingVoucherRules.rows[0]?.count, 0) const voucherProduct = await query<{ id: number }>( `INSERT INTO product_catalog ( canonical_sku, canonical_name, category, unit_name, status, attributes_json, created_at, updated_at ) VALUES ($1, $2, '卡券', '张', 'active', '{}'::jsonb, NOW(), NOW()) RETURNING id`, [`tpv:${voucherSku}`, `卡券展示名-${suffix}`], ) createdVoucherProductIds.push(Number(voucherProduct.rows[0]!.id)) assert.equal(await ensureVoucherRuleForSku(voucherSku), true) const voucherChannel = await query<{ channel: string source: string canonical_product_id: string | null priority: number is_fallback: boolean config_json: Record }>( `SELECT route.channel, route.source, route.canonical_product_id, route.priority, route.route_role = 'fallback' AS is_fallback, route.carrier_config_json AS config_json FROM sku_channel_routes route JOIN internal_skus sku ON sku.id = route.internal_sku_id WHERE sku.internal_sku_key = $1 ORDER BY route.channel`, [voucherSku], ) assert.equal(voucherChannel.rows.length, 1) assert.equal(voucherChannel.rows[0]?.channel, 'third_party_voucher') assert.equal(voucherChannel.rows[0]?.source, 'voucher') assert.equal( Number(voucherChannel.rows[0]?.canonical_product_id), createdVoucherProductIds[0], ) assert.equal(voucherChannel.rows[0]?.priority, 10) assert.equal(voucherChannel.rows[0]?.is_fallback, false) assert.equal(voucherChannel.rows[0]?.config_json.voucherSku, voucherSku) 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), ) const firstRulePage = await listChannelRulesPage({ channel: 'third_party_voucher', enabled: true, page: 1, pageSize: 2, }) assert.equal(firstRulePage.page, 1) assert.equal(firstRulePage.pageSize, 2) assert.ok(firstRulePage.items.length <= 2) assert.equal(firstRulePage.total, listedRules.length) const searchedRules = await listChannelRulesPage({ keyword: voucherSku, source: 'operator', enabled: true, page: 1, pageSize: 10, }) assert.ok(searchedRules.items.some((rule) => rule.id === savedRule.id)) assert.ok(searchedRules.items.every((rule) => rule.source === 'operator')) const deletedRules = await deleteChannelRules([savedRule.id]) assert.equal(deletedRules.deletedCount, 1) assert.deepEqual(deletedRules.deletedIds, [savedRule.id]) const archivedVoucherProduct = await query<{ id: number }>( `INSERT INTO product_catalog ( canonical_sku, canonical_name, category, unit_name, status, attributes_json, created_at, updated_at ) VALUES ( $1, $2, '卡券', '张', 'archived', '{"deletedAt":"2026-01-01T00:00:00.000Z","deletedBy":"integration_test"}'::jsonb, NOW(), NOW() ) RETURNING id`, [`tpv:${reactivatedVoucherSku}`, reactivatedVoucherSku], ) const archivedVoucherProductId = Number(archivedVoucherProduct.rows[0]!.id) createdVoucherProductIds.push(archivedVoucherProductId) const reactivatedRule = await upsertChannelRule({ matchKeyType: 'internal_sku', matchKey: reactivatedVoucherSku, channel: 'third_party_voucher', priority: 80, enabled: true, note: '集成测试重新激活归档商品', adminUserId: null, }) const reactivated = await query<{ status: string attributes_json: Record canonical_product_id: string | null priority: number is_fallback: boolean }>( `SELECT product.status, product.attributes_json, route.canonical_product_id, route.priority, route.route_role = 'fallback' AS is_fallback FROM sku_channel_routes route JOIN product_catalog product ON product.id = route.canonical_product_id WHERE route.id = $1`, [reactivatedRule.id], ) assert.equal(reactivated.rows[0]?.status, 'active') assert.equal(Number(reactivated.rows[0]?.canonical_product_id), archivedVoucherProductId) assert.equal(reactivated.rows[0]?.priority, 10) assert.equal(reactivated.rows[0]?.is_fallback, false) assert.equal(reactivated.rows[0]?.attributes_json.deletedAt, undefined) assert.equal(typeof reactivated.rows[0]?.attributes_json.reactivatedAt, 'string') const retryPendingItemId = await createPendingOrderItem(retryPendingAffiliateSku) await setRoute({ sku: retryPendingAffiliateSku, channel: 'affiliate_dash', configJson: { affiliateSku: retryPendingAffiliateSku }, }) await query( `UPDATE fulfillments SET status = 'assigned', channel = 'affiliate_dash', source = 'carrier_evidence', updated_at = NOW() WHERE order_item_id = $1`, [retryPendingItemId], ) const existingRetryTasks = await query<{ id: number; task_status: string }>( `SELECT id, task_status FROM fulfillment_tasks WHERE order_item_id = $1 ORDER BY id`, [retryPendingItemId], ) assert.deepEqual(existingRetryTasks.rows, [], `测试订单项已有任务:${retryPendingItemId}`) await query( `INSERT INTO fulfillment_tasks ( order_id, order_item_id, unit_index, task_no, provider, platform, shop_id, shop_name, platform_order_id, profile_id, executor_key, task_status, created_at, updated_at ) SELECT oi.order_id, oi.id, 1, $2, o.provider, o.platform, o.shop_id, o.shop_name, o.platform_order_id, profile.id, 'affiliate_dash', 'retry_pending', NOW(), NOW() FROM v_order_item_current oi JOIN orders o ON o.id = oi.order_id JOIN fulfillment_profiles profile ON profile.id = $3 AND profile.executor_key = 'affiliate_dash' WHERE oi.id = $1`, [retryPendingItemId, `IT-RETRY-PENDING-${suffix}`, fallbackProfileId], ) const retryPendingTask = await query<{ task_status: string }>( `SELECT task_status FROM fulfillment_tasks WHERE order_item_id = $1 AND executor_key = 'affiliate_dash' ORDER BY id DESC LIMIT 1`, [retryPendingItemId], ) assert.equal(retryPendingTask.rows[0]?.task_status, 'retry_pending') const blockedRetry = await reconcilePendingCarriers({ orderItemIds: [retryPendingItemId], includeAssignedMissingCarrier: true, limit: 1, }) assert.equal(blockedRetry.scanned, 0) assert.equal(blockedRetry.affiliateTasksCreated, 0) const retryPendingState = await query<{ fulfillment_status: string fulfillment_channel: string | null fulfillment_pending_reason: string | null fulfillment_pending_detail: Record task_count: number }>( `SELECT oi.fulfillment_status, oi.fulfillment_channel, oi.fulfillment_pending_reason, oi.fulfillment_pending_detail, (SELECT count(*)::int FROM fulfillment_tasks ft WHERE ft.order_item_id = oi.id) AS task_count FROM v_order_item_current oi WHERE oi.id = $1`, [retryPendingItemId], ) assert.equal(retryPendingState.rows[0]?.fulfillment_status, 'assigned') assert.equal(retryPendingState.rows[0]?.fulfillment_channel, 'affiliate_dash') assert.equal(retryPendingState.rows[0]?.fulfillment_pending_reason, null) assert.equal(retryPendingState.rows[0]?.task_count, 1) await query( `UPDATE fulfillments SET status = 'pending', channel = NULL, pending_reason = 'no_carrier', pending_detail = $2::jsonb, locked = TRUE, updated_at = NOW() WHERE order_item_id = $1`, [ retryPendingItemId, JSON.stringify({ internalSku: retryPendingAffiliateSku, channel: 'affiliate_dash', carrierIssue: 'carrier_task_retry_pending', }), ], ) const unlockedPendingGroup = await unlockPendingChannelGroup({ internalSku: retryPendingAffiliateSku, }) assert.equal(unlockedPendingGroup.updated, 1) const unlockedPendingItem = await query<{ fulfillment_locked: boolean }>( `SELECT fulfillment_locked FROM v_order_item_current WHERE id = $1`, [retryPendingItemId], ) assert.equal(unlockedPendingItem.rows[0]?.fulfillment_locked, false) await query( `UPDATE fulfillment_tasks SET task_status = 'closed', result_code = 'USER_APPLY_REFUND', updated_at = NOW() WHERE order_item_id = $1 AND executor_key = 'affiliate_dash'`, [retryPendingItemId], ) await query( `UPDATE fulfillments SET status = 'pending', channel = NULL, source = 'auto_mapping', pending_reason = NULL, pending_detail = NULL, updated_at = NOW() WHERE order_item_id = $1`, [retryPendingItemId], ) await assert.rejects( () => retryPendingCarrierGroup({ internalSku: retryPendingAffiliateSku, retryInactiveCarrier: true, issueCodes: ['user_refund'], }), /不允许重试/, ) const protectedRetryState = await query<{ fulfillment_status: string fulfillment_pending_detail: Record | null task_count: number }>( `SELECT oi.fulfillment_status, oi.fulfillment_pending_detail, (SELECT count(*)::int FROM fulfillment_tasks ft WHERE ft.order_item_id = oi.id) AS task_count FROM v_order_item_current oi WHERE oi.id = $1`, [retryPendingItemId], ) assert.equal(protectedRetryState.rows[0]?.fulfillment_status, 'pending') assert.equal(protectedRetryState.rows[0]?.fulfillment_pending_detail, null) assert.equal(protectedRetryState.rows[0]?.task_count, 1) const voucherJobPrefix = `IT-VOUCHER-LIST-${suffix}` const voucherJobs = await query<{ id: number }>( `INSERT INTO voucher_consume_jobs ( provider, channel, trigger_event, target_key, platform_order_id, due_at, status, attempt_count, max_attempts, updated_at ) VALUES ('kuaishou_industry', 'affiliate_dash', 'order_received', $1, $2, NOW(), 'succeeded', 1, 8, NOW()), ('kuaishou_industry', 'manual', 'order_received', $3, $4, NOW(), 'failed', 2, 8, NOW()), ('douyin_mashida', 'manual', 'order_received', $5, $6, NOW(), 'failed', 1, 8, NOW()) RETURNING id`, [ `${voucherJobPrefix}-KS-AFF`, `${voucherJobPrefix}-KS-AFF-ORDER`, `${voucherJobPrefix}-KS-MANUAL`, `${voucherJobPrefix}-KS-MANUAL-ORDER`, `${voucherJobPrefix}-DY-MANUAL`, `${voucherJobPrefix}-DY-MANUAL-ORDER`, ], ) const firstVoucherJobPage = await listVoucherConsumeJobs({ keyword: voucherJobPrefix, page: 1, pageSize: 2, }) assert.equal(firstVoucherJobPage.total, 3) assert.equal(firstVoucherJobPage.items.length, 2) assert.equal(firstVoucherJobPage.page, 1) assert.equal(firstVoucherJobPage.pageSize, 2) const secondVoucherJobPage = await listVoucherConsumeJobs({ keyword: voucherJobPrefix, page: 2, pageSize: 2, }) assert.equal(secondVoucherJobPage.total, 3) assert.equal(secondVoucherJobPage.items.length, 1) const filteredVoucherJobs = await listVoucherConsumeJobs({ keyword: voucherJobPrefix, provider: 'kuaishou_industry', channel: 'manual', status: 'failed', page: 1, pageSize: 20, }) assert.equal(filteredVoucherJobs.total, 1) assert.equal(filteredVoucherJobs.items[0]?.provider, 'kuaishou_industry') assert.equal(filteredVoucherJobs.items[0]?.channel, 'manual') assert.equal(filteredVoucherJobs.items[0]?.status, 'failed') const searchedVoucherJob = await listVoucherConsumeJobs({ keyword: String(voucherJobs.rows[1]?.id || ''), status: 'failed', page: 1, pageSize: 20, }) assert.ok(searchedVoucherJob.items.some((job) => job.id === voucherJobs.rows[1]?.id)) } 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 work_order_events WHERE work_order_id IN ( SELECT id FROM work_orders WHERE order_item_id = ANY($1::bigint[]) )`, [orderItemIds], ) await query(`DELETE FROM work_orders WHERE order_item_id = ANY($1::bigint[])`, [ orderItemIds, ]) await query( 'ALTER TABLE fulfillment_state_events DISABLE TRIGGER trg_fulfillment_state_events_append_only', ) try { await query(`DELETE FROM order_items WHERE id = ANY($1::bigint[])`, [orderItemIds]) } finally { await query( 'ALTER TABLE fulfillment_state_events ENABLE TRIGGER trg_fulfillment_state_events_append_only', ) } } 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 voucher_consume_jobs WHERE platform_order_id LIKE $1`, [ `IT-VOUCHER-LIST-${suffix}%`, ]) await query(`DELETE FROM manual_fulfillment_configs WHERE sku_key = ANY($1::text[])`, [ internalSkus, ]) await query( `DELETE FROM internal_sku_mappings WHERE provider = '91kaquan' AND shop_id = $1`, [shopId], ) await query( `DELETE FROM internal_skus WHERE internal_sku_key = ANY($1::text[])`, [internalSkus.map((sku) => sku.trim().normalize('NFKC').toLowerCase())], ) await query(`DELETE FROM manual_sku_registry WHERE sku_key = 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], ) const generatedProducts = await query<{ id: string }>( `SELECT id FROM product_catalog WHERE canonicalize_internal_sku(substring(canonical_sku from 5)) = ANY($1::text[])`, [internalSkus], ) const generatedProductIds = generatedProducts.rows.map((row) => Number(row.id)) if (generatedProductIds.length > 0) { await query( `DELETE FROM cost_snapshots WHERE canonical_product_id = ANY($1::bigint[]) OR cost_version_id IN ( SELECT id FROM cost_versions WHERE canonical_product_id = ANY($1::bigint[]) )`, [generatedProductIds], ) await query( `DELETE FROM sales_daily_facts WHERE canonical_product_id = ANY($1::bigint[])`, [generatedProductIds], ) await query( `DELETE FROM channel_product_mappings WHERE canonical_product_id = ANY($1::bigint[])`, [generatedProductIds], ) await query(`DELETE FROM cost_versions WHERE canonical_product_id = ANY($1::bigint[])`, [ generatedProductIds, ]) await query( `DELETE FROM product_channel_capabilities WHERE product_id = ANY($1::bigint[])`, [generatedProductIds], ) await query(`DELETE FROM product_catalog WHERE id = ANY($1::bigint[])`, [ generatedProductIds, ]) } if (retryWorkOrderRuleId) { await query(`DELETE FROM work_product_match_logs WHERE rule_id = $1`, [ retryWorkOrderRuleId, ]) await query(`DELETE FROM cost_versions WHERE work_product_rule_id = $1`, [ retryWorkOrderRuleId, ]) await query(`DELETE FROM work_product_rules WHERE id = $1`, [retryWorkOrderRuleId]) } if (fallbackProfileId) { await query(`DELETE FROM fulfillment_profiles WHERE id = $1`, [fallbackProfileId]) } await closeDb() } }, )