/** * 半自动任务真实 PostgreSQL 集成测试。 * * SEMI_AUTO_TASK_TEST_DATABASE_URL=postgres://... \ * npx tsx --test src/services/semi-auto/semi-auto-task.integration.test.ts */ import assert from 'node:assert/strict' import { randomUUID } from 'node:crypto' import test from 'node:test' const TEST_DATABASE_URL = String(process.env.SEMI_AUTO_TASK_TEST_DATABASE_URL || '').trim() /** 断言领域服务抛出指定错误码,避免只匹配中文提示。 */ async function expectErrorCode(fn: () => Promise, errorCode: string) { await assert.rejects(fn, (error: { errorCode?: string }) => { assert.equal(error.errorCode, errorCode) return true }) } test( '人工渠道半自动任务可由客户入口和后台列表幂等回填', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL const { closeDb, query, withTransaction } = await import('../../db/client.js') const { applySemiAutoTaskStateSnapshot, confirmPublicBinding, ensureSemiAutoTasksForOrder, exportAdminSemiAutoCredential, listAdminSemiAutoTasks, listPublicSemiAutoTasks, requestAdminSemiAutoCustomerReauth, resetPublicBinding, savePublicTaskProfile, startPublicBinding, } = await import('./semi-auto-task-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-SEMI-AUTO-${suffix}` const skuKey = `半自动测试-${suffix}` let orderId = 0 let configId = 0 let credentialId = 0 try { 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 ( '91kaquan', 'kuaishou-91', $1, '半自动测试店', $2, 'paid', 'paid', 1000, NOW(), NOW(), NOW() ) RETURNING id `, [`semi-auto-shop-${suffix}`, orderNo], ) orderId = Number(order.rows[0]?.id || 0) assert.ok(orderId > 0) const item = await query<{ id: number }>( ` INSERT INTO order_items ( order_id, sku_code, sku_name, quantity, spec_json, item_snapshot_json, revenue_amount_fen, revenue_basis, created_at, updated_at ) VALUES ( $1, $2, $3, 1, $4::jsonb, $4::jsonb, 1000, 'order_total', NOW(), NOW() ) RETURNING id `, [orderId, `semi-${suffix}`, skuKey, JSON.stringify({ skuNick: skuKey })], ) const orderItemId = Number(item.rows[0]?.id || 0) assert.ok(orderItemId > 0) const fulfillment = await query<{ id: number }>( 'SELECT id FROM fulfillments WHERE order_item_id = $1 LIMIT 1', [orderItemId], ) const fulfillmentId = Number(fulfillment.rows[0]?.id || 0) assert.ok(fulfillmentId > 0) const config = await query<{ id: number }>( ` INSERT INTO manual_fulfillment_configs ( sku_key, platform_key, credit_quantity, cost_mode, enabled, note, channels_json, semi_auto_enabled, semi_auto_platform, semi_auto_config_json, created_at, updated_at ) VALUES ( $1, 'fund_cash', 100, 'fixed', TRUE, '集成测试', '[{"platformKey":"fund_cash","creditQuantity":100,"costMode":"fixed","enabled":true}]'::jsonb, TRUE, 'huya', '{"pageTitle":"虎牙授权测试"}'::jsonb, NOW(), NOW() ) RETURNING id `, [skuKey], ) configId = Number(config.rows[0]?.id || 0) assert.ok(configId > 0) await query( ` UPDATE fulfillments SET channel = 'manual', status = 'assigned', fulfillment_config_id = $2, source = 'manual_confirm', updated_at = NOW() WHERE id = $1 `, [fulfillmentId, configId], ) // 客服工作台先打开时也必须看到任务,不能依赖客户先访问 `/c/订单号` 或 `/d/订单号`。 const adminList = await listAdminSemiAutoTasks({ keyword: orderNo }) assert.equal(adminList.pagination.total, 1) assert.equal(adminList.items[0]?.orderNo, orderNo) const first = await ensureSemiAutoTasksForOrder(orderNo) const second = await ensureSemiAutoTasksForOrder(orderNo) assert.equal(first.createdIds.length, 0) assert.equal(second.createdIds.length, 0) const tasks = await listPublicSemiAutoTasks(orderNo) assert.equal(tasks.length, 1) assert.equal(tasks[0]?.orderItemId, orderItemId) assert.equal(tasks[0]?.platform, 'huya') assert.equal(tasks[0]?.orderNo, orderNo) assert.equal(tasks[0]?.quantity, 1) assert.equal(tasks[0]?.semiAutoConfig.pageTitle, '虎牙授权测试') const taskId = Number(tasks[0]?.id || 0) // 客户页流程固定为「填写资料 → 登录 → 绑定角色」:资料可先保存,绑定仍要求登录。 const savedProfile = await savePublicTaskProfile(orderNo, taskId, { roleName: '集成测试角色', roleId: '1192083858', serverZone: '安卓V区', }) assert.equal(savedProfile.task.customerGameRoleName, '集成测试角色') assert.equal(savedProfile.task.customerGameRoleId, '1192083858') assert.equal(savedProfile.task.customerServerZone, '安卓V区') await expectErrorCode(() => startPublicBinding(orderNo, taskId), 'semi_auto_login_required') const credential = await query<{ id: number }>( ` INSERT INTO semi_auto_credentials ( platform, platform_uid, platform_nickname, credential_payload_json, credential_source, credential_status, credential_updated_at, last_checked_at, last_check_error, created_at, updated_at ) VALUES ( 'huya', $1, '集成测试虎牙', '{"cookies":[]}', 'qr', 'valid', NOW(), NOW(), '', NOW(), NOW() ) RETURNING id `, [`it-huya-${suffix}`], ) credentialId = Number(credential.rows[0]?.id || 0) await query( ` UPDATE semi_auto_tasks SET credential_id = $2, connector_session_id = $3, login_status = 'authenticated', binding_status = 'not_started', execution_status = 'waiting_operator', customer_link_opened_at = NOW(), authenticated_at = NOW(), updated_at = NOW() WHERE id = $1 `, [taskId, credentialId, `it-huya-session-${suffix}`], ) const authenticatedList = await listAdminSemiAutoTasks({ keyword: orderNo }) assert.equal(authenticatedList.items[0]?.loginStatus, 'authenticated') assert.equal(authenticatedList.items[0]?.displayStatus.label, '等待客户绑定角色') const exported = await exportAdminSemiAutoCredential(taskId) assert.equal(exported.credentialId, credentialId) assert.equal(exported.platform, 'huya') // 换绑失败后客户点「上一步修改资料」:清空绑定/换绑状态,保留登录与已填资料。 await query( ` UPDATE semi_auto_tasks SET binding_status = 'role_ready', bind_game_role = '平台原角色', bind_game_role_id = '99887766', bind_game_channel = '微信', binding_started_at = NOW(), bound_at = NOW(), last_error = '虎牙未接受本次换绑', updated_at = NOW() WHERE id = $1 `, [taskId], ) const reset = await resetPublicBinding(orderNo, taskId) assert.equal(reset.task.bindingStatus, 'not_started') assert.equal(reset.binding, null) assert.equal(reset.task.customerGameRoleName, '集成测试角色') assert.equal(reset.task.customerGameRoleId, '1192083858') assert.equal(reset.task.customerServerZone, '安卓V区') const resetRow = await query<{ binding_status: string bind_game_role: string bind_game_role_id: string bind_game_channel: string binding_started_at: string | null bound_at: string | null login_status: string credential_id: number | null connector_session_id: string customer_game_role_name: string customer_game_role_id: string customer_game_server_zone: string last_error: string execution_status: string }>( ` SELECT binding_status, bind_game_role, bind_game_role_id, bind_game_channel, binding_started_at, bound_at, login_status, credential_id, connector_session_id, customer_game_role_name, customer_game_role_id, customer_game_server_zone, last_error, execution_status FROM semi_auto_tasks WHERE id = $1 `, [taskId], ) const resetState = resetRow.rows[0] assert.equal(resetState?.binding_status, 'not_started') assert.equal(resetState?.bind_game_role, '') assert.equal(resetState?.bind_game_role_id, '') assert.equal(resetState?.bind_game_channel, '') assert.equal(resetState?.binding_started_at, null) assert.equal(resetState?.bound_at, null) assert.equal(resetState?.last_error, '') assert.equal(resetState?.execution_status, 'waiting_customer') assert.equal(resetState?.login_status, 'authenticated') assert.equal(Number(resetState?.credential_id), credentialId) assert.equal(resetState?.connector_session_id, `it-huya-session-${suffix}`) assert.equal(resetState?.customer_game_role_name, '集成测试角色') assert.equal(resetState?.customer_game_role_id, '1192083858') assert.equal(resetState?.customer_game_server_zone, '安卓V区') const resetEvents = await query<{ detail_json: { reason?: string } | null }>( ` SELECT detail_json FROM semi_auto_task_events WHERE task_id = $1 AND event_type = 'binding_reset' ORDER BY id DESC LIMIT 1 `, [taskId], ) assert.equal(resetEvents.rows[0]?.detail_json?.reason, 'customer_profile_edit') // 已确认绑定后的重新授权必须完整退出已授权状态,不能只清登录状态。 await query( ` UPDATE semi_auto_tasks SET binding_status = 'confirmed', bind_game_account = '集成测试虎牙账号', bind_game_role = '集成测试角色', bind_game_role_id = '1192083858', bind_game_channel = '安卓(iOS) · QQ', binding_started_at = NOW(), bound_at = NOW(), execution_status = 'waiting_operator', updated_at = NOW() WHERE id = $1 `, [taskId], ) const reauthorized = await requestAdminSemiAutoCustomerReauth(taskId, { userId: 1, role: 'support', displayName: '集成测试客服', } as never) assert.equal(reauthorized.task.loginStatus, 'waiting_login') assert.equal(reauthorized.task.bindingStatus, 'not_started') assert.equal(reauthorized.task.executionStatus, 'waiting_customer') assert.equal(reauthorized.task.customerLinkOpenedAt, null) assert.equal(reauthorized.task.bindGameAccount, '') assert.equal(reauthorized.task.bindGameRole, '') assert.equal(reauthorized.task.bindGameRoleId, '') assert.equal(reauthorized.task.bindGameChannel, '') assert.equal(reauthorized.task.boundAt, null) const retainedCredential = await query<{ credential_id: number }>( 'SELECT credential_id FROM semi_auto_tasks WHERE id = $1', [taskId], ) assert.equal(Number(retainedCredential.rows[0]?.credential_id), credentialId) assert.ok( reauthorized.events.some((event) => event.eventType === 'customer_reauth_requested'), ) const missingVersionEventId = randomUUID() await expectErrorCode( () => applySemiAutoTaskStateSnapshot( { eventId: missingVersionEventId, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'not_started', }, { eventId: missingVersionEventId, eventType: 'semi_auto.task_state' }, ), 'semi_auto_snapshot_state_version_required', ) const snapshotEventId = randomUUID() const snapshot = await applySemiAutoTaskStateSnapshot( { eventId: snapshotEventId, stateVersion: 2, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'confirmed', huyaUid: `it-huya-${suffix}`, bindGameAccount: '集成测试虎牙账号', bindGameRole: '集成测试角色', bindGameRoleToken: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', bindGameChannel: '安卓(android) · 微信', isBindAccount: true, isBindRole: true, roleIdentitySource: 'huya_outer_current', verificationBasis: 'role_name_zone', }, { eventId: snapshotEventId, eventType: 'semi_auto.task_state' }, ) assert.equal(snapshot.applied, true) const reusedUidEventId = randomUUID() await expectErrorCode( () => applySemiAutoTaskStateSnapshot( { eventId: reusedUidEventId, stateVersion: 3, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'role_ready', huyaUid: '1199664118656', platformGameRoleUid: '1199664118656', bindGameRole: '集成测试角色', bindGameChannel: '安卓(android) · QQ', }, { eventId: reusedUidEventId, eventType: 'semi_auto.task_state' }, ), 'semi_auto_snapshot_platform_role_uid_reused', ) const duplicateSnapshot = await applySemiAutoTaskStateSnapshot( { eventId: snapshotEventId, stateVersion: 2, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'confirmed', }, { eventId: snapshotEventId, eventType: 'semi_auto.task_state' }, ) assert.equal(duplicateSnapshot.applied, false) const synced = await query<{ login_status: string binding_status: string execution_status: string bind_game_role_token: string role_identity_source: string verification_basis: string }>( `SELECT login_status, binding_status, execution_status, bind_game_role_token, role_identity_source, verification_basis FROM semi_auto_tasks WHERE id = $1`, [taskId], ) assert.deepEqual(synced.rows[0], { login_status: 'authenticated', binding_status: 'confirmed', execution_status: 'waiting_operator', bind_game_role_token: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', role_identity_source: 'huya_outer_current', verification_basis: 'role_name_zone', }) const staleConfirmEventId = randomUUID() await applySemiAutoTaskStateSnapshot( { eventId: staleConfirmEventId, stateVersion: 3, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'confirmed', huyaUid: `it-huya-${suffix}`, bindGameAccount: '集成测试虎牙账号', bindGameRole: '错误角色', bindGameRoleToken: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', bindGameChannel: '安卓(android) · 微信', isBindAccount: true, isBindRole: true, roleIdentitySource: 'huya_outer_current', verificationBasis: 'role_name_zone', }, { eventId: staleConfirmEventId, eventType: 'semi_auto.task_state' }, ) const decisionGated = await query<{ execution_status: string binding_flow_state: string }>( `SELECT execution_status, binding_flow_state FROM semi_auto_tasks WHERE id = $1`, [taskId], ) assert.deepEqual(decisionGated.rows[0], { execution_status: 'waiting_customer', binding_flow_state: 'rebind_required', }) const outOfOrderEventId = randomUUID() const outOfOrder = await applySemiAutoTaskStateSnapshot( { eventId: outOfOrderEventId, stateVersion: 2, taskId, orderNo, loginStatus: 'authenticated', bindingStatus: 'confirmed', huyaUid: `it-huya-${suffix}`, bindGameAccount: '集成测试虎牙账号', bindGameRole: '集成测试角色', bindGameRoleToken: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', bindGameChannel: '安卓(android) · 微信', isBindAccount: true, isBindRole: true, roleIdentitySource: 'huya_outer_current', verificationBasis: 'role_name_zone', }, { eventId: outOfOrderEventId, eventType: 'semi_auto.task_state' }, ) assert.equal(outOfOrder.applied, false) assert.equal(outOfOrder.stale, true) const afterOutOfOrder = await query<{ binding_flow_state: string; execution_status: string }>( `SELECT binding_flow_state, execution_status FROM semi_auto_tasks WHERE id = $1`, [taskId], ) assert.deepEqual(afterOutOfOrder.rows[0], { binding_flow_state: 'rebind_required', execution_status: 'waiting_customer', }) } finally { if (orderId > 0) { await query('DELETE FROM order_source_snapshots WHERE order_id = $1', [orderId]) await query('DELETE FROM orders WHERE id = $1', [orderId]) } if (credentialId > 0) { await query('DELETE FROM semi_auto_credentials WHERE id = $1', [credentialId]) } if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } await closeDb() } }, ) test( '半自动完成失败会连同财务确认一起回滚,成功后重复完成不重复扣成本', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL const { closeDb, query } = await import('../../db/client.js') const { completeAdminSemiAutoTask, ensureSemiAutoTasksForOrder } = await import('./semi-auto-task-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-SEMI-AUTO-ATOMIC-${suffix}` const skuKey = `半自动原子性-${suffix}` const triggerName = `trg_semi_auto_atomic_${suffix}` const functionName = `fn_semi_auto_atomic_${suffix}` let orderId = 0 let configId = 0 let adminId = 0 let credentialId = 0 let triggerCreated = false try { const admin = await query<{ id: number }>( `INSERT INTO admin_users (username, password_hash, role, status, created_at, updated_at) VALUES ($1, 'x', 'support', 'active', NOW(), NOW()) RETURNING id`, [`it_semi_auto_admin_${suffix}`], ) adminId = Number(admin.rows[0]?.id || 0) assert.ok(adminId > 0) 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 ( '91kaquan', 'kuaishou-91', $1, '半自动原子性测试店', $2, 'paid', 'paid', 1000, NOW(), NOW(), NOW() ) RETURNING id `, [`semi-auto-atomic-shop-${suffix}`, orderNo], ) orderId = Number(order.rows[0]?.id || 0) assert.ok(orderId > 0) const item = await query<{ id: number }>( ` INSERT INTO order_items ( order_id, sku_code, sku_name, quantity, spec_json, item_snapshot_json, revenue_amount_fen, revenue_basis, created_at, updated_at ) VALUES ( $1, $2, $3, 1, $4::jsonb, $4::jsonb, 1000, 'order_total', NOW(), NOW() ) RETURNING id `, [orderId, `semi-atomic-${suffix}`, skuKey, JSON.stringify({ skuNick: skuKey })], ) const orderItemId = Number(item.rows[0]?.id || 0) assert.ok(orderItemId > 0) const fulfillment = await query<{ id: number }>( 'SELECT id FROM fulfillments WHERE order_item_id = $1 LIMIT 1', [orderItemId], ) const fulfillmentId = Number(fulfillment.rows[0]?.id || 0) assert.ok(fulfillmentId > 0) const config = await query<{ id: number }>( ` INSERT INTO manual_fulfillment_configs ( sku_key, platform_key, credit_quantity, cost_mode, enabled, note, channels_json, semi_auto_enabled, semi_auto_platform, semi_auto_config_json, created_at, updated_at ) VALUES ( $1, 'on_account', 0, 'variable', TRUE, '原子性集成测试', '[{"platformKey":"on_account","creditQuantity":0,"costMode":"variable","enabled":true}]'::jsonb, TRUE, 'huya', '{}'::jsonb, NOW(), NOW() ) RETURNING id `, [skuKey], ) configId = Number(config.rows[0]?.id || 0) assert.ok(configId > 0) await query( ` UPDATE fulfillments SET channel = 'manual', status = 'assigned', fulfillment_config_id = $2, source = 'manual_confirm', updated_at = NOW() WHERE id = $1 `, [fulfillmentId, configId], ) const ensured = await ensureSemiAutoTasksForOrder(orderNo) const taskId = Number(ensured.createdIds[0] || 0) assert.ok(taskId > 0) const credential = await query<{ id: number }>( ` INSERT INTO semi_auto_credentials ( platform, platform_uid, platform_nickname, credential_payload_json, credential_source, credential_status, credential_updated_at, last_checked_at, last_check_error, created_at, updated_at ) VALUES ( 'huya', $1, '半自动原子性账号', '{"cookies":[]}', 'qr', 'valid', NOW(), NOW(), '', NOW(), NOW() ) RETURNING id `, [`it-atomic-huya-${suffix}`], ) credentialId = Number(credential.rows[0]?.id || 0) assert.ok(credentialId > 0) await query( ` UPDATE semi_auto_tasks SET credential_id = $2, login_status = 'authenticated', binding_status = 'confirmed', binding_flow_state = 'confirmed', execution_status = 'waiting_operator', customer_game_role_name = '半自动原子性角色', customer_game_role_id = '1192083858', customer_game_server_zone = '安卓V区', bind_game_role = '半自动原子性角色', bind_game_role_token = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', bind_game_channel = '安卓(android) · 微信', is_bind_account = TRUE, is_bind_role = TRUE, bound_at = NOW(), authenticated_at = NOW(), updated_at = NOW() WHERE id = $1 `, [taskId, credentialId], ) await query( ` CREATE OR REPLACE FUNCTION ${functionName}() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF NEW.execution_status = 'completed' THEN RAISE EXCEPTION 'forced semi auto completion failure'; END IF; RETURN NEW; END; $$ `, ) await query( ` CREATE TRIGGER ${triggerName} BEFORE UPDATE OF execution_status ON semi_auto_tasks FOR EACH ROW EXECUTE FUNCTION ${functionName}() `, ) triggerCreated = true const session = { userId: adminId, role: 'support', displayName: '半自动原子性客服', } as never await assert.rejects( () => completeAdminSemiAutoTask( taskId, { costFen: 123, note: '触发任务更新失败以验证回滚' }, session, ), /forced semi auto completion failure/, ) const rolledBack = await query<{ execution_status: string snapshot_count: number bill_count: number fulfillment_channel: string }>( ` SELECT task.execution_status, (SELECT COUNT(*)::int FROM cost_snapshots cs WHERE cs.order_item_id = $2) AS snapshot_count, (SELECT COUNT(*)::int FROM on_account_bills oab WHERE oab.order_item_id = $2) AS bill_count, f.channel AS fulfillment_channel FROM semi_auto_tasks task JOIN fulfillments f ON f.id = task.fulfillment_id WHERE task.id = $1 `, [taskId, orderItemId], ) assert.equal(rolledBack.rows[0]?.execution_status, 'waiting_operator') assert.equal(Number(rolledBack.rows[0]?.snapshot_count), 0) assert.equal(Number(rolledBack.rows[0]?.bill_count), 0) assert.equal(rolledBack.rows[0]?.fulfillment_channel, 'manual') await query(`DROP TRIGGER ${triggerName} ON semi_auto_tasks`) triggerCreated = false await query(`DROP FUNCTION ${functionName}()`) const completed = await completeAdminSemiAutoTask( taskId, { costFen: 123, note: '事务重试成功' }, session, ) assert.equal(completed.task.executionStatus, 'completed') const afterCompletion = await query<{ snapshot_count: number; bill_count: number }>( ` SELECT (SELECT COUNT(*)::int FROM cost_snapshots cs WHERE cs.order_item_id = $1) AS snapshot_count, (SELECT COUNT(*)::int FROM on_account_bills oab WHERE oab.order_item_id = $1) AS bill_count `, [orderItemId], ) assert.equal(Number(afterCompletion.rows[0]?.snapshot_count), 1) assert.equal(Number(afterCompletion.rows[0]?.bill_count), 1) await completeAdminSemiAutoTask(taskId, { costFen: 123 }, session) const afterDuplicate = await query<{ snapshot_count: number }>( 'SELECT COUNT(*)::int AS snapshot_count FROM cost_snapshots WHERE order_item_id = $1', [orderItemId], ) assert.equal(Number(afterDuplicate.rows[0]?.snapshot_count), 1) } finally { if (triggerCreated) { await query(`DROP TRIGGER IF EXISTS ${triggerName} ON semi_auto_tasks`) } await query(`DROP FUNCTION IF EXISTS ${functionName}()`) if (orderId > 0) { await query( 'DELETE FROM cost_snapshots WHERE order_item_id IN (SELECT id FROM order_items WHERE order_id = $1)', [orderId], ) await query( 'DELETE FROM on_account_bills WHERE order_item_id IN (SELECT id FROM order_items WHERE order_id = $1)', [orderId], ) await query( 'DELETE FROM cost_exceptions WHERE subject_id IN (SELECT id FROM order_items WHERE order_id = $1)', [orderId], ) await query('DELETE FROM orders WHERE id = $1', [orderId]) } // 已过账总账凭证按财务规则不可物理删除;测试只清理可重建销售投影。 await query( `DELETE FROM sales_daily_facts WHERE stat_date = (NOW() AT TIME ZONE 'Asia/Shanghai')::date`, ) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } if (credentialId > 0) { await query('DELETE FROM semi_auto_credentials WHERE id = $1', [credentialId]) } if (adminId > 0) { await query('DELETE FROM admin_users WHERE id = $1', [adminId]) } await closeDb() } }, ) test( '人工配置切换半自动平台会终止旧任务并创建新的活动任务', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const { reconcileSemiAutoTasksForManualConfig } = await import('./semi-auto-task-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-SEMI-AUTO-PLATFORM-SWITCH-${suffix}` let orderId = 0 let configId = 0 try { const result = await createSemiAutoMock({ orderNo, skuName: `半自动平台切换-${suffix}`, quantity: 1, connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId await query( `UPDATE manual_fulfillment_configs SET semi_auto_platform = 'weibo', updated_at = NOW() WHERE id = $1`, [configId], ) const reconciled = await reconcileSemiAutoTasksForManualConfig(configId) assert.equal(reconciled.createdIds.length, 1) const tasks = await query<{ id: number platform: string execution_status: string last_error: string }>( `SELECT id, platform, execution_status, last_error FROM semi_auto_tasks WHERE order_id = $1 ORDER BY id`, [orderId], ) assert.equal(tasks.rows.length, 2) assert.equal(tasks.rows[0]?.platform, 'huya') assert.equal(tasks.rows[0]?.execution_status, 'cancelled') assert.match(tasks.rows[0]?.last_error || '', /切换半自动平台/) assert.equal(tasks.rows[1]?.platform, 'weibo') assert.equal(tasks.rows[1]?.execution_status, 'waiting_customer') await query( `UPDATE manual_fulfillment_configs SET semi_auto_enabled = FALSE, updated_at = NOW() WHERE id = $1`, [configId], ) await reconcileSemiAutoTasksForManualConfig(configId) const disabled = await query<{ platform: string; execution_status: string }>( `SELECT platform, execution_status FROM semi_auto_tasks WHERE order_id = $1 ORDER BY id`, [orderId], ) assert.deepEqual(disabled.rows, [ { platform: 'huya', execution_status: 'cancelled' }, { platform: 'weibo', execution_status: 'cancelled' }, ]) } finally { if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '虎牙确认状态可从数据库恢复并在回查角色一致后收敛为已确认', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query, withTransaction } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const { loadTask, updateBindingTaskWithClient } = await import('./semi-auto-task-core.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-HUYA-CONFIRM-RECOVERY-${suffix}` const targetRoleToken = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' let orderId = 0 let configId = 0 try { const result = await createSemiAutoMock({ orderNo, skuName: `虎牙确认恢复-${suffix}`, quantity: 1, connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId await query( ` UPDATE semi_auto_tasks SET login_status = 'authenticated', customer_game_role_name = '恢复目标角色', customer_game_role_id = '1192083858', customer_game_server_zone = '安卓V区', binding_status = 'scanned', bind_game_role = '旧角色', bind_game_role_token = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', bind_game_channel = '安卓(android) · 微信', is_bind_account = TRUE, is_bind_role = TRUE, pending_bind_game_role = '恢复目标角色', pending_bind_game_role_token = $2, pending_bind_game_channel = '安卓(android) · 微信', bind_confirm_state = 'accepted', binding_effect_deadline_at = NOW() + INTERVAL '1 minute', execution_status = 'waiting_customer', updated_at = NOW() WHERE id = $1 `, [result.taskId, targetRoleToken], ) const task = await loadTask(result.taskId) await withTransaction((client) => updateBindingTaskWithClient( client, task.id, { sessionId: task.connector_session_id, status: 'role_ready', qrImage: '', qrExpiresAt: '', qrUrl: '', bindGameAccount: '恢复目标账号', bindGameRole: '恢复目标角色', bindGameRoleId: targetRoleToken, bindGameRoleToken: targetRoleToken, bindGameChannel: '安卓(android) · 微信', currentRole: { isBindAccount: true, isBindRole: true, roleName: '恢复目标角色', roleToken: targetRoleToken, channel: '安卓(android) · 微信', changeBindTime: 0, changeBindDay: 7, }, pendingRole: null, hasExistingBinding: true, rebindRequested: false, message: '平台角色已生效', }, 'connector', ), ) const recovered = await loadTask(result.taskId) assert.equal(recovered.binding_status, 'confirmed') assert.equal(recovered.binding_flow_state, 'confirmed') assert.equal(recovered.execution_status, 'waiting_operator') assert.equal(recovered.bind_confirm_state, 'idle') assert.equal(recovered.pending_bind_game_role, '') assert.ok(recovered.bound_at) } finally { if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '半自动后台列表按任务创建顺序稳定分页,状态刷新不会导致行跳位', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const { listAdminSemiAutoTasks } = await import('./semi-auto-task-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const keyword = `IT-SEMI-AUTO-STABLE-${suffix}` const created: Array<{ orderId: number; configId: number; taskId: number }> = [] try { for (const label of ['A', 'B']) { const result = await createSemiAutoMock({ orderNo: `${keyword}-${label}`, skuName: `半自动稳定排序-${suffix}-${label}`, quantity: 1, connectorMode: 'embedded', }) created.push({ orderId: result.orderId, configId: result.configId, taskId: result.taskId, }) } const first = created[0]! const second = created[1]! await query( ` UPDATE semi_auto_tasks SET created_at = NOW() - INTERVAL '2 minutes', updated_at = NOW() + INTERVAL '2 minutes', execution_status = 'waiting_operator' WHERE id = $1 `, [first.taskId], ) await query( ` UPDATE semi_auto_tasks SET created_at = NOW() - INTERVAL '1 minute', updated_at = NOW() - INTERVAL '1 minute', execution_status = 'waiting_customer' WHERE id = $1 `, [second.taskId], ) const result = await listAdminSemiAutoTasks({ keyword, page: 1, pageSize: 20 }) assert.deepEqual( result.items.map((item) => item.id), [second.taskId, first.taskId], ) } finally { for (const item of created.reverse()) { await query('DELETE FROM orders WHERE id = $1', [item.orderId]) await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [item.configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '微博账号 CK 以账号级 Cookie JSON 保存并可加载', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL const { closeDb, query, withTransaction } = await import('../../db/client.js') const { loadSemiAutoCredential, upsertSemiAutoCredentialWithClient } = await import('./semi-auto-credential-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` let credentialId = 0 try { credentialId = await withTransaction((client) => upsertSemiAutoCredentialWithClient(client, { platform: 'weibo', source: 'sms', payload: { platformUid: `it-weibo-${suffix}`, nickname: '集成测试微博', cookies: [ { name: 'SUB', value: `secret-sub-${suffix}`, domain: '.weibo.com', path: '/', secure: true, httpOnly: true, }, ], }, }), ) const raw = await query<{ credential_payload_json: string credential_source: string credential_status: string }>( `SELECT credential_payload_json, credential_source, credential_status FROM semi_auto_credentials WHERE id = $1`, [credentialId], ) assert.equal(raw.rows[0]?.credential_source, 'sms') assert.equal(raw.rows[0]?.credential_status, 'valid') assert.match(raw.rows[0]?.credential_payload_json || '', /"cookies"/) const credential = await loadSemiAutoCredential(credentialId) assert.equal(credential?.platformUid, `it-weibo-${suffix}`) assert.equal(credential?.cookies[0]?.value, `secret-sub-${suffix}`) } finally { if (credentialId > 0) { await query('DELETE FROM semi_auto_credentials WHERE id = $1', [credentialId]) } await closeDb() } }, ) test( '开发 Mock 可生成半自动履约测试单并回填任务', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-MOCK-SA-${suffix}` const skuKey = `半自动Mock-${suffix}` let orderId = 0 let configId = 0 try { const result = await createSemiAutoMock({ orderNo, skuName: skuKey, quantity: 1, pageTitle: 'Mock 集成测试', connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId assert.ok(result.orderItemId > 0) assert.ok(result.fulfillmentId > 0) assert.ok(result.taskId > 0) assert.equal(result.connectorMode, 'embedded') assert.equal(result.customerPath, `/c/${encodeURIComponent(orderNo)}`) const row = await query<{ channel: string fulfillment_status: string fulfillment_config_id: number semi_auto_enabled: boolean semi_auto_platform: string connector_mode: string login_status: string binding_status: string execution_status: string }>( ` SELECT f.channel, f.status AS fulfillment_status, f.fulfillment_config_id, cfg.semi_auto_enabled, cfg.semi_auto_platform, task.connector_mode, task.login_status, task.binding_status, task.execution_status FROM semi_auto_tasks task JOIN fulfillments f ON f.id = task.fulfillment_id JOIN manual_fulfillment_configs cfg ON cfg.id = task.manual_fulfillment_config_id WHERE task.order_item_id = $1 `, [result.orderItemId], ) assert.equal(row.rows[0]?.channel, 'manual') assert.equal(row.rows[0]?.fulfillment_status, 'assigned') assert.equal(Number(row.rows[0]?.fulfillment_config_id), result.configId) assert.equal(row.rows[0]?.semi_auto_enabled, true) assert.equal(row.rows[0]?.semi_auto_platform, 'huya') assert.equal(row.rows[0]?.connector_mode, 'embedded') assert.equal(row.rows[0]?.login_status, 'waiting_login') assert.equal(row.rows[0]?.binding_status, 'not_started') assert.equal(row.rows[0]?.execution_status, 'waiting_customer') } finally { if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '虎牙数据库 CK 可在进程会话丢失后恢复并生成浏览器注入票据', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query, withTransaction } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const { upsertSemiAutoCredentialWithClient } = await import('./semi-auto-credential-service.js') const { createAdminBrowserSession, consumeSemiAutoInjectionTicket } = await import('./semi-auto-task-service.js') const { huyaNativeConnector } = await import('./huya-native/huya-native-connector.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-HUYA-RESTORE-${suffix}` const platformUid = '1686664168' let orderId = 0 let configId = 0 let credentialId = 0 let adminId = 0 let restoredSessionId = '' try { const admin = await query<{ id: number }>( `INSERT INTO admin_users (username, password_hash, role, status, created_at, updated_at) VALUES ($1, 'x', 'support', 'active', NOW(), NOW()) RETURNING id`, [`it_huya_restore_admin_${suffix}`], ) adminId = Number(admin.rows[0]?.id || 0) const result = await createSemiAutoMock({ orderNo, skuName: `虎牙CK恢复-${suffix}`, quantity: 1, pageTitle: '虎牙CK恢复集成测试', connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId credentialId = await withTransaction((client) => upsertSemiAutoCredentialWithClient(client, { platform: 'huya', source: 'sms', payload: { platformUid, nickname: '虎牙恢复测试', cookies: [ { name: 'yyuid', value: platformUid, domain: '.huya.com', path: '/', secure: true, httpOnly: false, expiresAt: null, }, { name: 'udb_uid', value: platformUid, domain: '.huya.com', path: '/', secure: true, httpOnly: false, expiresAt: null, }, { name: 'udb_cred', value: `restored-${suffix}`, domain: '.huya.com', path: '/', secure: true, httpOnly: false, expiresAt: null, }, ], }, }), ) await query( `UPDATE semi_auto_tasks SET credential_id = $2, connector_session_id = $3, huya_uid = $4, login_status = 'authenticated', binding_status = 'not_started', execution_status = 'waiting_operator', updated_at = NOW() WHERE id = $1`, [result.taskId, credentialId, `missing-session-${suffix}`, platformUid], ) const ticket = await createAdminBrowserSession(result.taskId, 'https://www.huya.com/', { userId: adminId, role: 'support', displayName: '集成测试客服', } as never) const restored = await query<{ connector_session_id: string credential_session_restored: number }>( `SELECT task.connector_session_id, COUNT(event.id) FILTER ( WHERE event.event_type = 'credential_session_restored' )::int AS credential_session_restored FROM semi_auto_tasks task LEFT JOIN semi_auto_task_events event ON event.task_id = task.id WHERE task.id = $1 GROUP BY task.connector_session_id`, [result.taskId], ) restoredSessionId = String(restored.rows[0]?.connector_session_id || '') assert.ok(restoredSessionId) assert.notEqual(restoredSessionId, `missing-session-${suffix}`) assert.equal(Number(restored.rows[0]?.credential_session_restored), 1) const payload = await consumeSemiAutoInjectionTicket(ticket.ticket) assert.equal( payload.cookies.find((cookie) => cookie.name === 'udb_cred')?.value, `restored-${suffix}`, ) } finally { if (restoredSessionId) { await huyaNativeConnector.revokeSession(restoredSessionId).catch(() => undefined) } if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (credentialId > 0) { await query('DELETE FROM semi_auto_credentials WHERE id = $1', [credentialId]) } if (adminId > 0) { await query('DELETE FROM admin_users WHERE id = $1', [adminId]) } if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '微博平台角色绑定事实收敛为等待客服处理', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query, withTransaction } = await import('../../db/client.js') const { createSemiAutoIntegrationMock } = await import('../dev-mock/dev-mock-service.js') const { loadTask, updateBindingTask } = await import('./semi-auto-task-core.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-WEIBO-BINDING-${suffix}` let orderId = 0 let configId = 0 let mappingId = 0 try { const result = await createSemiAutoIntegrationMock({ platform: 'weibo', orderNo, skuName: `微博绑定真实链路-${suffix}`, quantity: 1, connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId mappingId = result.mappingId assert.equal(result.semiAutoPlatform, 'weibo') assert.ok(result.taskId > 0) await query( ` UPDATE semi_auto_tasks SET connector_session_id = $2, login_status = 'authenticated', execution_status = 'waiting_customer', authenticated_at = NOW(), updated_at = NOW() WHERE id = $1 `, [result.taskId, `it-weibo-session-${suffix}`], ) const task = await loadTask(result.taskId) const binding = await updateBindingTask( task, { sessionId: `it-weibo-session-${suffix}`, status: 'confirmed', qrImage: '', qrExpiresAt: '', qrUrl: '', bindGameAccount: '集成测试微博', bindGameRole: '微博游戏角色', bindGameRoleId: '', bindGameChannel: '微信', hasExistingBinding: true, rebindRequested: false, rebindCooldownDays: 0, nextRebindAt: '', message: '微博账号已绑定角色', }, 'connector', ) assert.equal(binding.status, 'confirmed') assert.equal(binding.comparison.verdict, 'unknown') assert.equal(binding.comparison.message, '当前不是虎牙绑定任务') const stored = await query<{ binding_status: string execution_status: string bind_game_role: string bind_game_channel: string }>( `SELECT binding_status, execution_status, bind_game_role, bind_game_channel FROM semi_auto_tasks WHERE id = $1`, [result.taskId], ) assert.equal(stored.rows[0]?.binding_status, 'confirmed') assert.equal(stored.rows[0]?.execution_status, 'waiting_operator') assert.equal(stored.rows[0]?.bind_game_role, '微博游戏角色') assert.equal(stored.rows[0]?.bind_game_channel, '微信') } finally { await withTransaction(async (client) => { await client.query("SET LOCAL session_replication_role = 'replica'") if (configId > 0) { await client.query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } if (orderId > 0) { await client.query('DELETE FROM order_source_snapshots WHERE order_id = $1', [orderId]) await client.query('DELETE FROM orders WHERE id = $1', [orderId]) } if (mappingId > 0) { await client.query('DELETE FROM internal_sku_mappings WHERE id = $1', [mappingId]) } }) delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '开发 Mock 可显式选择内置 Mock Connector', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-MOCK-SA-MOCK-${suffix}` let orderId = 0 let configId = 0 try { const result = await createSemiAutoMock({ orderNo, skuName: `半自动Mock连接器-${suffix}`, quantity: 1, connectorMode: 'mock', }) orderId = result.orderId configId = result.configId assert.equal(result.connectorMode, 'mock') const row = await query<{ connector_mode: string }>( 'SELECT connector_mode FROM semi_auto_tasks WHERE id = $1', [result.taskId], ) assert.equal(row.rows[0]?.connector_mode, 'mock') } finally { if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '客户先保存虎牙角色资料,再完成短信登录并保存 CK', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query } = await import('../../db/client.js') const { createSemiAutoMock } = await import('../dev-mock/dev-mock-service.js') const { resetMockSessions } = await import('../dev-mock/mock-semi-auto-connector.js') const { listPublicSemiAutoTasks, loginPublicHuyaSms, savePublicTaskProfile, sendPublicHuyaSmsCode, } = await import('./semi-auto-task-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-HUYA-SMS-${suffix}` let orderId = 0 let configId = 0 let credentialId = 0 try { const result = await createSemiAutoMock({ orderNo, skuName: `虎牙短信登录-${suffix}`, quantity: 1, connectorMode: 'mock', }) orderId = result.orderId configId = result.configId const saved = await savePublicTaskProfile(orderNo, result.taskId, { roleName: 'Mock虎牙角色', serverZone: '安卓V区', }) assert.equal(saved.task.customerGameRoleId, '') assert.equal(saved.task.loginStatus, 'waiting_login') assert.equal(saved.task.displayStatus.label, '等待客户授权') const sent = await sendPublicHuyaSmsCode(orderNo, result.taskId, '13800138000') assert.equal(sent.ok, true) const waiting = await query<{ connector_session_id: string login_status: string execution_status: string }>( `SELECT connector_session_id, login_status, execution_status FROM semi_auto_tasks WHERE id = $1`, [result.taskId], ) assert.ok(waiting.rows[0]?.connector_session_id) assert.equal(waiting.rows[0]?.login_status, 'waiting_login') assert.equal(waiting.rows[0]?.execution_status, 'waiting_customer') await loginPublicHuyaSms(orderNo, result.taskId, { mobile: '13800138000', code: '123456', }) const tasks = await listPublicSemiAutoTasks(orderNo) assert.equal(tasks[0]?.loginStatus, 'authenticated') // 虎牙登录成功只代表取得 CK,仍需完成角色绑定,不能直接进入等待客服。 assert.equal(tasks[0]?.executionStatus, 'waiting_customer') assert.equal(tasks[0]?.displayStatus.label, '等待客户绑定角色') assert.equal(tasks[0]?.customerGameRoleName, 'Mock虎牙角色') assert.equal(tasks[0]?.customerGameRoleId, '') assert.equal(tasks[0]?.credentialSource, 'sms') assert.ok(tasks[0]?.huyaUid) assert.equal(tasks[0]?.platformNickname, 'Mock虎牙用户') const stored = await query<{ id: number credential_source: string credential_payload_json: string platform_nickname: string huya_uid: string }>( `SELECT credential.id, credential.credential_source, credential.credential_payload_json, task.platform_nickname, task.huya_uid FROM semi_auto_tasks task JOIN semi_auto_credentials credential ON credential.id = task.credential_id WHERE task.id = $1`, [result.taskId], ) credentialId = Number(stored.rows[0]?.id || 0) assert.ok(credentialId > 0) assert.equal(stored.rows[0]?.credential_source, 'sms') assert.match(stored.rows[0]?.credential_payload_json || '', /mock_huya_session/) assert.equal(stored.rows[0]?.platform_nickname, 'Mock虎牙用户') assert.equal(stored.rows[0]?.huya_uid, tasks[0]?.huyaUid) } finally { if (orderId > 0) await query('DELETE FROM orders WHERE id = $1', [orderId]) if (configId > 0) { await query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } if (credentialId > 0) { await query('DELETE FROM semi_auto_credentials WHERE id = $1', [credentialId]) } resetMockSessions() delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '真实订单入口可生成 manual 履约和半自动任务', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query, withTransaction } = await import('../../db/client.js') const { createSemiAutoIntegrationMock } = await import('../dev-mock/dev-mock-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-INTEGRATION-SA-${suffix}` let orderId = 0 let configId = 0 let mappingId = 0 try { const result = await createSemiAutoIntegrationMock({ platform: 'huya', orderNo, skuName: `真实链路虎牙测试-${suffix}`, quantity: 1, connectorMode: 'embedded', }) orderId = result.orderId configId = result.configId mappingId = result.mappingId assert.equal(result.pipeline, 'order_service') assert.equal(result.orderNo, orderNo) assert.ok(result.orderItemId > 0) assert.ok(result.fulfillmentId > 0) assert.ok(result.taskId > 0) const stored = await query<{ channel: string fulfillment_status: string login_status: string execution_status: string config_id: number }>( ` SELECT f.channel, f.status AS fulfillment_status, task.login_status, task.execution_status, task.manual_fulfillment_config_id AS config_id FROM semi_auto_tasks task JOIN fulfillments f ON f.id = task.fulfillment_id WHERE task.id = $1 `, [result.taskId], ) assert.equal(stored.rows[0]?.channel, 'manual') assert.equal(stored.rows[0]?.fulfillment_status, 'assigned') assert.equal(stored.rows[0]?.login_status, 'waiting_login') assert.equal(stored.rows[0]?.execution_status, 'waiting_customer') assert.equal(Number(stored.rows[0]?.config_id), result.configId) const mapping = await query<{ internal_sku: string }>( 'SELECT internal_sku FROM internal_sku_mappings WHERE id = $1', [result.mappingId], ) assert.equal(mapping.rows[0]?.internal_sku, result.skuKey) } finally { await withTransaction(async (client) => { await client.query("SET LOCAL session_replication_role = 'replica'") if (configId > 0) { await client.query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } if (orderId > 0) { await client.query('DELETE FROM order_source_snapshots WHERE order_id = $1', [orderId]) await client.query('DELETE FROM orders WHERE id = $1', [orderId]) } if (mappingId > 0) { await client.query('DELETE FROM internal_sku_mappings WHERE id = $1', [mappingId]) } }) delete process.env.ENABLE_DEV_MOCK await closeDb() } }, ) test( '斗鱼直播账号履约 Mock 只生成正式人工履约,不生成半自动任务', { skip: !TEST_DATABASE_URL ? '未设置 SEMI_AUTO_TASK_TEST_DATABASE_URL' : false }, async () => { process.env.DATABASE_URL = TEST_DATABASE_URL process.env.ENABLE_DEV_MOCK = '1' const { closeDb, query, withTransaction } = await import('../../db/client.js') const { createDouyuFulfillmentMock } = await import('../dev-mock/dev-mock-service.js') const suffix = `${Date.now()}_${Math.floor(Math.random() * 1_000_000)}` const orderNo = `IT-DOUYU-FULFILLMENT-${suffix}` const skuKey = `斗鱼精英宝典联调-${suffix}` let orderId = 0 let configId = 0 let mappingId = 0 try { const result = await createDouyuFulfillmentMock({ orderNo, skuName: skuKey, }) orderId = result.orderId configId = result.configId mappingId = result.mappingId assert.equal(result.platform, 'douyu') assert.equal(result.pipeline, 'order_service') assert.equal(result.orderNo, orderNo) assert.equal(result.skuKey, skuKey) assert.ok(result.orderItemId > 0) assert.ok(result.fulfillmentId > 0) const stored = await query<{ channel: string fulfillment_status: string fulfillment_config_id: number semi_auto_enabled: boolean semi_auto_task_count: number internal_sku: string }>( ` SELECT f.channel, f.status AS fulfillment_status, f.fulfillment_config_id, cfg.semi_auto_enabled, ( SELECT COUNT(*)::int FROM semi_auto_tasks task WHERE task.order_item_id = f.order_item_id ) AS semi_auto_task_count, resolve_internal_sku(oi.manual_sku_key, oi.sku_name, oi.sku_code) AS internal_sku FROM fulfillments f JOIN order_items oi ON oi.id = f.order_item_id JOIN manual_fulfillment_configs cfg ON cfg.id = f.fulfillment_config_id WHERE f.id = $1 `, [result.fulfillmentId], ) assert.equal(stored.rows[0]?.channel, 'manual') assert.equal(stored.rows[0]?.fulfillment_status, 'assigned') assert.equal(Number(stored.rows[0]?.fulfillment_config_id), result.configId) assert.equal(stored.rows[0]?.semi_auto_enabled, false) assert.equal(Number(stored.rows[0]?.semi_auto_task_count), 0) assert.equal(stored.rows[0]?.internal_sku, skuKey) const mapping = await query<{ internal_sku: string }>( 'SELECT internal_sku FROM internal_sku_mappings WHERE id = $1', [result.mappingId], ) assert.equal(mapping.rows[0]?.internal_sku, skuKey) } finally { await withTransaction(async (client) => { await client.query("SET LOCAL session_replication_role = 'replica'") if (configId > 0) { await client.query('DELETE FROM manual_fulfillment_configs WHERE id = $1', [configId]) } if (orderId > 0) { await client.query('DELETE FROM order_source_snapshots WHERE order_id = $1', [orderId]) await client.query('DELETE FROM orders WHERE id = $1', [orderId]) } if (mappingId > 0) { await client.query('DELETE FROM internal_sku_mappings WHERE id = $1', [mappingId]) } }) delete process.env.ENABLE_DEV_MOCK await closeDb() } }, )