// 只读断言:直接加载现有组件方法,禁止发出真实业务请求。 const assert = require('assert/strict'); const fs = require('fs'); const path = require('path'); const vm = require('vm'); const root = path.resolve(__dirname, '..'); const folder = path.join(root, 'src/views/warehouseManagement/index'); const compiler = require(path.join(root, 'node_modules/vue-template-compiler')); function load(file, bindings = {}) { let source = fs.readFileSync(path.join(folder, file), 'utf8'); if (file.endsWith('.vue')) source = compiler.parseComponent(source).script.content; source = source.replace(/^import .*;$/gm, '').replace(/export default/, 'module.exports =').replace(/export (function|const)/g, '$1'); const context = { module: { exports: {} }, ...bindings }; vm.runInNewContext(source, context, { filename: file }); return { value: context.module.exports, context }; } const { context: utils } = load('dashboard-utils.js'); const { monthRange, cleanQuery, displayNumber, findPortalEntry, formatPpChange, fillStagnantDays } = utils; // const 导出只落在 vm 上下文的词法作用域里、不会成为上下文属性,所以用 runInContext 取回常量, // 再作为绑定传给组件脚本(组件里的 import 被 load() 剥掉了)。 const utilConst = (name) => vm.runInContext(name, utils); const STAGNANT_DEFAULT_DAYS = utilConst('STAGNANT_DEFAULT_DAYS'); assert.equal(STAGNANT_DEFAULT_DAYS, 180, '呆滞阈值默认回落值必须是 180 天'); assert.equal(utilConst('STAGNANT_DAYS_PLACEHOLDER'), '{stagnantDays}', '口径条占位符必须与 dashboard-screens.js 的文案一致'); // 百分点差值:带符号 + 固定 2 位小数 + pp 单位,0 视为持平。 // 这条坏了会把「占比抬升」显示成没有单位的小数,用户无法判断是 pp 还是 %。 assert.equal(formatPpChange(0.5), '+0.50pp', '上升必须带 + 号、2 位小数与 pp 单位'); assert.equal(formatPpChange(-1.2), '-1.20pp', '下降必须带 - 号,不能用 0 顶替'); assert.equal(formatPpChange(0), '持平', '差值为 0 只显示持平,不显示 +0.00pp'); assert.equal(formatPpChange(null), '—', '空值返回占位符,调用方不得把它当 0 展示'); // 阈值占位符替换:有值用值,缺失回落 180;不含占位符的文案原样返回(其它屏必须一字不改)。 assert.equal(fillStagnantDays('库龄超过 {stagnantDays} 天', 90), '库龄超过 90 天'); assert.equal(fillStagnantDays('库龄超过 {stagnantDays} 天', null), '库龄超过 180 天', '阈值缺失必须回落默认 180 天'); assert.equal(fillStagnantDays('库龄超过 {stagnantDays} 天', 0), '库龄超过 180 天', '非法阈值(0)也要回落默认值'); assert.equal(fillStagnantDays('无占位符文案', 90), '无占位符文案', '不含占位符的屏幕文案必须原样返回'); assert.equal(monthRange(new Date(2024, 1, 15)).endTime, '2024-02-29 23:59:59'); assert.equal(monthRange(new Date(2026, 11, 31)).startTime, '2026-12-01 00:00:00'); assert.equal(displayNumber(null), '—'); assert.equal(displayNumber(''), '—'); assert.equal(displayNumber(0), '0'); assert.equal(cleanQuery({ id: '9223372036854775806', status: 0, scope: false, empty: '', missing: null }).id, '9223372036854775806'); assert.equal(cleanQuery({ status: 0 }).status, '0'); assert.equal(cleanQuery({ scope: false }).scope, 'false'); const menus = [{ path: '/page-wt', children: [{ path: '/bpm', children: [{ path: 'todo', component: 'bpm/todo/index' }] }] }]; assert.equal(findPortalEntry(menus, n => /bpm\/todo/.test(n.component || '')), '/page-wt/bpm/todo'); assert.equal(findPortalEntry([{ path: '/page-eom', children: [{ path: '/purchasingManage/purchaseNeedManage', name: '采购' }] }], n => n.name === '采购'), '/page-eom/purchasingManage/purchaseNeedManage'); assert.equal(findPortalEntry([{ path: 'https://example.com', name: '外部' }], () => true), ''); assert.equal(findPortalEntry(menus, n => n.name === '无权限菜单'), ''); let calls = 0; const { context: screens } = load('dashboard-screens.js'); const { value: page } = load('dashboard.vue', { HomeOverview: {}, DashboardDetail: {}, DashboardActions: {}, ...utils, screens: vm.runInContext('screens', screens), dashboardAction: async () => { calls++; return [{ key: 'a', success: true }, { key: 'b', success: false }]; } }); for (const entry of ['index.vue', 'common.vue', 'yuxin.vue']) { const source = fs.readFileSync(path.join(folder, entry), 'utf8'); assert.match(source, /from ['"]\.\/dashboard\.vue['"]/); assert.doesNotMatch(source, /from ['"]\.\/index\.vue['"]/); } const open = { filters: { categoryId: '1', stockBatchId: '2' }, view: 'home', route(view, filters) { this.target = view; this.nextFilters = filters; } }; page.methods.open.call(open, 'todo', { type: 'inventory' }); assert.equal(open.nextFilters.type, 'inventory'); page.methods.open.call(open, 'ioapp'); assert.equal(open.nextFilters.status, '0'); assert.equal(open.nextFilters.unit, undefined, '出入库申请不再透传单位参数(后端已删除 unit)'); assert.equal(open.nextFilters.categoryId, undefined); const receipt = { receiveQueue: [{ id: '1' }, { id: '2' }], preparedReceipts: [], receiving: false, $route: { query: { inId: '1' } }, nextReceipt() {} }; page.methods.prepareReceipt.call(receipt, { sourceBizNo: 'R1' }); page.methods.prepareReceipt.call(receipt, { sourceBizNo: 'R1' }); assert.equal(receipt.preparedReceipts.length, 1, '旧表单重复事件不能准备到下一张申请'); // 计算属性在真实 Vue 实例里通过 this 互相访问;这里用 defineProperty 复现同一解析方式, // 否则 kpis 里读取 this.stockWeekOverWeek / this.stockValueWeekOverWeek 会拿到 undefined。 function componentState(component, overrides = {}) { const state = { ...overrides }; for (const [key, getter] of Object.entries(component.computed || {})) { Object.defineProperty(state, key, { configurable: true, get: () => getter.call(state) }); } return state; } const { value: overview } = load('components/HomeOverview.vue', { DashboardChart: {}, ...utils, STAGNANT_DEFAULT_DAYS }); const kpis = overview.computed.kpis.call(componentState(overview, { summary: {}, unit: '吨' })); // 「在库批次数」不再是一个业务统计维度:首页 KPI 行不得再有该卡(含其 key/字段),否则等于把废弃维度又渲染回来。 assert.equal(kpis.some(item => item.key === 'stock'), false, '首页不再展示在库批次数卡:该维度业务上不存在'); assert.equal(kpis.some(item => item.label === '在库批次数'), false, '首页 KPI 不得出现「在库批次数」文案'); assert.equal(kpis.some(item => item.value === undefined && item.unit === '批'), false, '首页不得残留批次数口径的卡片'); assert.equal(kpis.find(item => item.key === 'value').target, 'stockLedger'); // 库存金额卡改为台账口径 Σ(在库数量×台账单价):值只取 summary.ledgerInventoryValue, // 空 summary 时为 undefined(交给 displayKpi 显示占位符),绝不用 0 或 '' 冒充「零库存」。 const valueEmpty = kpis.find(item => item.key === 'value'); assert.equal(valueEmpty.value, undefined, '库存金额只读 ledgerInventoryValue,空 summary 不得回退成 0 或空串'); // 台账口径与历史成本价周环比不可比:卡片不再有任何角标,delta 与 deltaTitle 两个字段都不存在。 assert.equal(valueEmpty.delta, undefined, '库存金额卡已不展示较上周,delta 必须不存在(空串也算残留)'); assert.equal(valueEmpty.deltaTitle, undefined, 'deltaTitle 随「较上周」一并移除'); // 即使 summary 同时下发了成本价口径的金额与周环比字段,库存金额卡也不得读它们、更不得渲染成角标; // 口径说明只能来自 ledgerInventoryReason,不能被 valuationReason 顶替。 const valueReady = overview.computed.kpis.call(componentState(overview, { summary: { ledgerInventoryValue: 12345.67, ledgerInventoryReason: '台账口径:Σ(在库数量×台账单价),未计价行不计入', inventoryValue: 999.99, inventoryValueChangeRate: 8.5, comparisonBaseAt: '2026-10-19 23:59:00', valuationReason: '成本价覆盖 70/70' }, unit: '吨' })).find(item => item.key === 'value'); assert.equal(valueReady.value, 12345.67, '库存金额必须取 ledgerInventoryValue,不得退回成本价口径的 inventoryValue'); assert.equal(valueReady.delta, undefined, '台账口径下不展示较上周,inventoryValueChangeRate 有值也不得渲染角标'); assert.equal(valueReady.deltaTitle, undefined, '台账口径下 deltaTitle 同样不存在'); assert.equal(valueReady.reason, '台账口径:Σ(在库数量×台账单价),未计价行不计入', '库存金额卡口径说明只来自 ledgerInventoryReason'); // 只有旧成本价口径原因时卡片留白且不回退:summary 里没有 ledgerInventory* 字段, // value/delta 都是 undefined,reason 也不得退回 valuationReason。 const valueUnknown = overview.computed.kpis.call(componentState(overview, { summary: { valuationReason: '已计价 3/70 个批次,存在缺价批次' }, unit: '' })).find(item => item.key === 'value'); assert.equal(valueUnknown.value, undefined, '台账金额字段缺失时交给 displayKpi 显示占位符,不得用 0 兜底'); assert.equal(valueUnknown.delta, undefined, '台账金额缺失时同样不出现角标'); assert.equal(valueUnknown.reason, undefined, 'ledgerInventoryReason 缺失时不得回退成本价口径的 valuationReason'); // 后端明确下发 null(未计价行全被剔除)时原样透传,displayKpi 显示占位符,不得改写成 0。 const valueNull = overview.computed.kpis.call(componentState(overview, { summary: { ledgerInventoryValue: null }, unit: '' })).find(item => item.key === 'value'); assert.equal(valueNull.value, null, 'ledgerInventoryValue 为 null 时原样透传,不得用 0 替代'); // 库存总量卡(本期新增,插在队首):台账口径 Σ库存台账计量数量、含锁定,跨计量单位直接汇总故不带单位后缀; // value 只认后端 ledgerInventoryQuantity,前端不乘加数量与单价;点击仍下钻库存台账。 const ledgerKpi = (summary) => overview.computed.kpis.call(componentState(overview, { summary, unit: '吨' })).find(item => item.key === 'ledger'); assert.equal(ledgerKpi({}).target, 'stockLedger', '库存总量卡必须可点击下钻库存台账'); assert.equal(ledgerKpi({}).unit, '', '库存总量跨计量单位汇总,不得带任何单位后缀'); assert.equal(ledgerKpi({ ledgerInventoryQuantity: 0 }).value, 0, '真实零库存必须显示 0,不能被缺失兜底吞掉'); assert.equal(ledgerKpi({}).value, undefined, 'ledgerInventoryQuantity 缺失时留白,不得用 0 兜底'); assert.equal(ledgerKpi({ ledgerInventoryQuantity: 1234.56, ledgerInventoryReason: '台账口径:Σ计量数量,含锁定量' }).value, 1234.56, '库存总量只读 ledgerInventoryQuantity,前端不得二次计算'); assert.equal(ledgerKpi({ ledgerInventoryQuantity: 1234.56, ledgerInventoryReason: '台账口径:Σ计量数量,含锁定量' }).reason, '台账口径:Σ计量数量,含锁定量', '库存总量卡口径说明来自 ledgerInventoryReason'); const todos = overview.computed.todoCards.call({ summary: {} }); // 待办条下钻目标:入/出库都必须落到 V13 出入库申请,各自带自己的 direction。 // 这两条坏了会把待出库单送进入总库申请(inapp),卡片数字与下钻列表立刻对不上。 const todoOf = (key) => todos.find(item => item.key === key); assert.equal(todoOf('in').target, 'ioapp', '待入库单必须下钻 V13 出入库申请(入库页签),落到其它入口会让卡片数字与列表对不上'); assert.equal(todoOf('out').target, 'ioapp', '待出库单必须下钻 V13 出入库申请(出库页签),指向 inapp 会让卡片数字与列表对不上'); assert.equal((todoOf('in').filters || {}).direction, 'in', '待入库单必须显式带 direction=in,不能依赖 open() 的兜底'); assert.equal((todoOf('out').filters || {}).direction, 'out', '待出库单必须下钻出库页签(direction=out),否则卡片数字与下钻列表对不上'); // 盘点任务进行中:必须跳本系统「盘点工单」菜单真实路由,且不得带任何筛选参数。 // 工单列表后端(PlanOrderPagePO)只认仓库名称/状态,没有 warehouseId 与计划完成时间条件, // 传参只会让 URL 假装被筛过;一旦有人改回内嵌 todo 视图(target:'todo'),这条会立刻变红。 assert.equal(todoOf('check').target, 'work', '盘点任务进行中必须跳盘点工单菜单,不能退回看板内嵌 todo 视图'); assert.deepEqual(todoOf('check').filters, undefined, '盘点工单菜单不接受仓库 id/状态筛选,卡片不得携带 filters'); const checkClick = { $emit(type, arg, extra) { this.event = { type, arg, extra }; } }; overview.methods.goTodoCard.call(checkClick, todoOf('check')); assert.equal(checkClick.event.type, 'navigate', '盘点任务进行中必须走 navigate(真实路由),不能走 open(看板内视图)'); assert.equal(checkClick.event.arg, '/warehouseManagement/stocktaking/work', '盘点工单菜单路径必须是 /warehouseManagement/stocktaking/work'); assert.equal(checkClick.event.extra, undefined, '跳盘点工单菜单不得携带 query,避免与后端实际可筛条件不一致'); // 库存周转卡片:目标/预警天数、状态、较上月差值全部由后端下发,前端只做映射展示。 const turnoverKpi = (summary, unit = '天') => overview.computed.kpis.call(componentState(overview, { summary, unit })).find(item => item.key === 'turnover'); const turnoverBase = { turnoverDays: 52.5, turnoverTargetDays: 45, turnoverWarnDays: 60, turnoverAsOf: '2026-10-19' }; // 状态四态:颜色与文案只认后端的 达标/超目标/偏慢,null 走中性色并留空文案。 // 这条坏了说明前端又在自算阈值,仓库配置的目标/预警天数会失效、健康度会误报。 assert.equal(turnoverKpi({ ...turnoverBase, turnoverStatus: '达标' }).color, '#3BD48A', '达标必须取后端状态给绿色,前端自算阈值会误报健康度'); assert.equal(turnoverKpi({ ...turnoverBase, turnoverStatus: '达标' }).status, '达标', '达标文案必须来自后端 turnoverStatus'); assert.equal(turnoverKpi({ ...turnoverBase, turnoverStatus: '超目标' }).color, '#ffb020', '超目标必须取橙色,否则看不出已过目标值'); assert.equal(turnoverKpi({ ...turnoverBase, turnoverStatus: '偏慢' }).color, '#F25E5E', '偏慢必须取红色,否则周转偏慢会被当成正常'); assert.equal(turnoverKpi({ ...turnoverBase, turnoverStatus: '偏慢' }).status, '周转偏慢', '偏慢文案沿用“周转偏慢”的既有措辞'); const turnoverUnknown = turnoverKpi({ ...turnoverBase, turnoverStatus: null }); assert.equal(turnoverUnknown.color, '#9FB8D4', '状态缺失必须回落中性色,不能凭空判定健康度'); assert.equal(turnoverUnknown.status, '', '状态缺失时状态文案留空,不得由前端补造'); // 较上月四态:负值(周转加快)绿、正值红、0 持平、null 只给原因。 // 这条坏了会把「上月不可比」显示成 0 天,等于伪造环比数据。 const turnoverDown = turnoverKpi({ ...turnoverBase, turnoverStatus: '达标', turnoverChange: -3.2 }); assert.match(turnoverDown.delta, /较前月 -3\.2 天/, '周转天数下降要显示“较前月 -3.2 天”'); assert.equal(turnoverDown.deltaTone, 'good', '差值下降是向好,必须走绿色语义'); const turnoverUp = turnoverKpi({ ...turnoverBase, turnoverStatus: '偏慢', turnoverChange: 8 }); assert.equal(turnoverUp.deltaTone, 'bad', '差值上升是变慢,必须走红色语义'); assert.match(turnoverUp.delta, /较前月 \+8 天/, '周转天数上升要显示带正号的差值'); const turnoverFlat = turnoverKpi({ ...turnoverBase, turnoverStatus: '达标', turnoverChange: 0 }); assert.equal(turnoverFlat.delta, '较前月持平', '差值 0 只显示持平,不显示 0 天'); assert.equal(turnoverFlat.deltaTone, 'dim', '持平不带健康度色调'); const turnoverNoChange = turnoverKpi({ ...turnoverBase, turnoverStatus: '达标', turnoverChange: null, turnoverChangeReason: '上月无日末快照' }); assert.equal(turnoverNoChange.delta, '', '不可比时不在角标展示原因'); assert.equal(turnoverNoChange.deltaTitle, '上月无日末快照', '不可比原因仍保留在提示中'); assert.doesNotMatch(turnoverNoChange.delta, /0 天/, '不可比绝不显示成 0 天'); // 后端字段未上线的过渡态:卡片必须能渲染,用中性色与空状态兜底,页面不报错。 const turnoverLegacy = turnoverKpi({}); assert.equal(turnoverLegacy.color, '#9FB8D4', '后端字段缺失时用中性色,不能让卡片崩掉'); assert.equal(turnoverLegacy.status, '', '后端字段缺失时状态留空'); assert.equal(turnoverLegacy.delta, '', '没有 turnoverChange 时不显示环比,更不能显示 0'); assert.equal(turnoverLegacy.value, undefined, '周转天数为空时交给 displayKpi 显示占位符'); // T+1 标注:日末快照日期来自 turnoverAsOf,格式不可信时退回「截至昨日」。 // 这条坏了用户会把 T+1 的旧值当成实时值看。 assert.match(turnoverKpi({ ...turnoverBase, turnoverStatus: '达标' }).subtotal.text, /统计至 2026-10-19 日末/, '必须标注完整月期末快照日期'); assert.match(turnoverKpi({ ...turnoverBase, turnoverStatus: '达标', turnoverAsOf: '2026/10/19' }).subtotal.text, /上月日末待核实/, 'asOf 格式不符时应提示待核实'); assert.match(turnoverKpi({ ...turnoverBase, turnoverStatus: '达标', turnoverAsOf: null }).subtotal.text, /上月日末待核实/, 'asOf 为空时应提示待核实'); // 防回归:周转阈值判定只能在后端,源码里不得再出现 turnoverDays 的比较运算。 // 这条坏了意味着有人把 45/60 写回前端,仓库配置的目标/预警天数立刻失效。 const overviewSource = fs.readFileSync(path.join(folder, 'components/HomeOverview.vue'), 'utf8'); assert.doesNotMatch(overviewSource, /turnoverDays\s*<=/, '周转阈值判定必须留在后端,前端写回 <= 会让仓库配置失效'); assert.doesNotMatch(overviewSource, /turnoverDays\s*>=/, '周转阈值判定必须留在后端,前端写回 >= 会让仓库配置失效'); assert.doesNotMatch(overviewSource, /turnover(Days|TargetDays|WarnDays)\s*[<>]/, '周转/目标/预警天数不得在前端做大小比较,阈值由后端唯一判定'); // 呆滞品占比卡片:分级、阈值、环比差值全部由后端下发,前端只做映射。 // 分级必须只认后端 stagnantLevel:前端一旦重算 8%/10%,仓库配置的天数阈值与 +0.5pp 入口级立刻失效。 const stagnantKpi = (summary) => overview.computed.kpis.call(componentState(overview, { summary, unit: '%' })).find(item => item.key === 'stagnant'); // 后端契约:stagnantBatchCount=呆滞批次数(分子 X),stagnantKnownBatchCount=可核实批次数(分母 Y), // stagnantUnknownBatchCount=日期未知批次数;总批次=known+unknown,只用于文案,不参与比值。 // 这里刻意让「分子 3 / 分母 70 / 日期未知 5」三者互不相同,任何把分子当分母或拿总数顶替的写法都会露馅。 const stagnantBase = { stagnantRate: 4.29, stagnantDays: 180, stagnantBatchCount: 3, stagnantKnownBatchCount: 70, stagnantUnknownBatchCount: 5 }; assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal' }).color, '#3BD48A', 'normal 必须映射绿色'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal' }).status, '正常', 'normal 文案为“正常”'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'near' }).color, '#ffb020', 'near 必须映射橙色'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'near' }).status, '接近阈值', 'near 文案为“接近阈值”'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'alert' }).color, '#F25E5E', 'alert 必须映射红色'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'alert' }).status, '呆滞预警', 'alert 文案为“呆滞预警”'); // 红优先:占比 <10% 但后端因环比入口级判 alert 时,前端不得用 8%/10% 把红色改回橙色。 assert.equal(stagnantKpi({ ...stagnantBase, stagnantRate: 8.2, stagnantLevel: 'alert', stagnantChange: 0.6 }).color, '#F25E5E', '分级以后端为准,alert 不得被前端重算成橙色'); // +0.5pp 入口级:占比仅 8.2%(未到 10%),后端因环比抬升 >= +0.5pp 判 near,前端必须照映射走橙色与“接近阈值”。 // 这条坏了意味着环比入口级在后端生效、前端却按 8%/10% 把它显示成绿色「正常」。 const stagnantEntry = stagnantKpi({ ...stagnantBase, stagnantRate: 8.2, stagnantLevel: 'near', stagnantChange: 0.5, stagnantBaseDate: '2026-09-30' }); assert.equal(stagnantEntry.color, '#ffb020', '+0.5pp 入口级必须走橙色,不得由前端按 8% 自行判绿'); assert.equal(stagnantEntry.status, '接近阈值', '+0.5pp 入口级文案为“接近阈值”'); assert.match(stagnantEntry.delta, /较上月 \+0\.50pp/, '入口级差值必须原样展示 +0.50pp'); const stagnantUnknown = stagnantKpi({ ...stagnantBase, stagnantLevel: null }); assert.equal(stagnantUnknown.color, '#9FB8D4', '分级缺失必须回落中性色,不能凭空判定健康度'); assert.equal(stagnantUnknown.status, '', '分级缺失时状态文案留空,不得由前端补造'); // 环比单位 pp:有值带符号 + pp 单位 + 基准日末;上升(恶化)走 bad、下降走 good、0 持平,与同屏周转卡一致。 const stagnantUp = stagnantKpi({ ...stagnantBase, stagnantLevel: 'alert', stagnantChange: 0.6, stagnantBaseDate: '2026-09-30' }); assert.match(stagnantUp.delta, /较上月 \+0\.60pp/, '环比必须带正号与 pp 单位'); assert.match(stagnantUp.delta, /2026-09-30 日末/, '环比必须标注上月最后一个完整日结快照日期'); assert.equal(stagnantUp.deltaTone, 'bad', '呆滞占比上升是恶化,与同屏周转卡统一走 bad(红)'); const stagnantDown = stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal', stagnantChange: -1.2, stagnantBaseDate: '2026-09-30' }); assert.match(stagnantDown.delta, /较上月 -1\.20pp/, '下降必须带负号,不能取绝对值'); assert.equal(stagnantDown.deltaTone, 'good', '占比下降是好转,走绿色语义'); const stagnantFlat = stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal', stagnantChange: 0, stagnantBaseDate: '2026-09-30' }); assert.equal(stagnantFlat.delta, '较上月持平(基准 2026-09-30 日末)', '差值为 0 只显示持平,不显示 +0.00pp'); assert.equal(stagnantFlat.deltaTone, 'dim', '持平不带健康度色调'); // 环比不可比时角标留空,原因保留在提示。 const stagnantNoChange = stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal', stagnantChange: null, stagnantChangeReason: '上月无完整日结快照' }); assert.equal(stagnantNoChange.delta, '', '不可比时角标留空'); assert.equal(stagnantNoChange.deltaTitle, '上月无完整日结快照', '不可比时原因保留在提示'); assert.doesNotMatch(stagnantNoChange.delta, /0\.00pp|\+0/, '不可比绝不显示 +0.00pp'); assert.equal(stagnantNoChange.delta === '0' || /\+?0(\.0+)?pp/.test(stagnantNoChange.delta), false, '不可比时不得以 0 或 +0.00pp 顶替'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'near', stagnantChange: null }).deltaTone, 'dim', '环比缺失时色调必须中性,不得暗示上升或下降'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal', stagnantChange: null, stagnantReason: '多仓汇总按默认 180 天' }).deltaTitle, '多仓汇总按默认 180 天', '环比原因缺失时提示回落到口径原因'); assert.equal(stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal', stagnantChange: null }).deltaTitle, '数据待核实', '两个原因都缺失时提示待核实'); // 分子/分母不可颠倒:占比复核必须用 呆滞批次数 ÷ 可核实批次数(3÷70=4.29%), // 错用 3÷75 或 70÷75 说明有人把 stagnantBatchCount 当分母、或拿总批次顶替可核实分母。 const stagnantRatio = stagnantKpi({ ...stagnantBase, stagnantLevel: 'normal' }).subtotal.title; assert.match(stagnantRatio, /呆滞 3 批次 ÷ 可核实 70 批次 = 4\.29%/, 'X/Y 必须用 known 作分母:3÷70=4.29%,不是 3÷75 或 70÷75'); assert.doesNotMatch(stagnantRatio, /= 4%/, '不得把 3÷75 的近似值当成复核比值'); assert.doesNotMatch(stagnantRatio, /= 93\.33%/, '不得把 70÷75 当成呆滞占比'); // 分母缺失(Y 缺失)时比值不可计算,只标注信息缺失,绝不拿总批次顶替分母。 const stagnantNoDenominator = stagnantKpi({ stagnantBatchCount: 3, stagnantUnknownBatchCount: 5, stagnantLevel: 'normal' }); assert.match(stagnantNoDenominator.info, /可核实批次数待核实/, '分母缺失必须标注待核实,不能拿 total 冒充可核实分母'); assert.match(stagnantNoDenominator.subtotal.title, /比值不可计算/, '分母缺失时不得给出任何比值'); assert.equal(stagnantNoDenominator.progress, null, '占比缺失时进度条必须为 null,不得用近似值顶替'); // 阈值与可核实分母:info 文案取后端 stagnantDays;缺失时天数位仍是 180 天,但括号注明是默认阈值。 assert.match(stagnantKpi({ ...stagnantBase, stagnantDays: 90, stagnantLevel: 'near' }).info, /库龄 > 90 天的呆滞批次数 ÷ 可核实批次数/, 'info 阈值必须取后端 stagnantDays(口径=仅库龄,不含无消耗条件)'); assert.match(stagnantKpi({ ...stagnantBase, stagnantDays: 90, stagnantLevel: 'near' }).info, /可核实 70\/75 批次/, 'info 必须给出可核实 X/Y 批次(X=可核实,Y=可核实+日期未知)'); assert.match(stagnantKpi({ ...stagnantBase, stagnantDays: null, stagnantLevel: 'near' }).info, /库龄 > 180 天(默认阈值,仓库未配置)的呆滞批次数 ÷ 可核实批次数/, '阈值缺失时天数位仍是 180 天,来源写在括号里'); assert.doesNotMatch(stagnantKpi({ ...stagnantBase, stagnantDays: null, stagnantLevel: 'near' }).info, /按默认 180 天/, '不得把“按默认”塞进天数位置,形成半截句子'); assert.doesNotMatch(stagnantKpi({ ...stagnantBase, stagnantDays: null, stagnantLevel: 'near' }).info, /\{stagnantDays\}/, 'info 不得漏出占位符字面量'); // 后端字段未上线的过渡态:卡片能渲染、中性色、状态留空、环比为空、不出现 NaN。 const stagnantLegacy = stagnantKpi({}); assert.equal(stagnantLegacy.color, '#9FB8D4', '后端字段缺失时用中性色,不能让卡片崩掉'); assert.equal(stagnantLegacy.status, '', '后端字段缺失时状态留空'); assert.equal(stagnantLegacy.delta, '', '后端字段缺失时角标留空'); assert.equal(stagnantLegacy.deltaTitle, '数据待核实', '后端字段缺失时原因保留在提示'); assert.equal(stagnantLegacy.progress, null, '占比为空时进度条不渲染,不能用 0 冒充'); assert.match(stagnantLegacy.info, /可核实批次数待核实/, '分母字段缺失时标注待核实'); // 防回归:8%/10% 判级必须留在后端,HomeOverview 不得再对 stagnantRate 做大小比较。 assert.doesNotMatch(overviewSource, /stagnantRate\s*[<>]/, '呆滞分级必须留在后端,前端写回 8%/10% 会让仓库阈值与 +0.5pp 入口级失效'); assert.match(overviewSource, /STAGNANT_LEVEL_STYLE/, '分级映射表必须存在,否则状态与颜色无从映射'); // 分子/分母守卫(源码级):stagnantBatchCount 是分子,不得出现在除号右侧; // 也不得用 known+batchCount 之类的兜底表达式把分子拼进分母。行为级证据是上面的 3÷70=4.29% 断言。 assert.doesNotMatch(overviewSource, /\/\s*s?\.?\s*stagnantBatchCount/, 'stagnantBatchCount 是分子,不得出现在除号右侧当分母'); // 允许 s. 前缀,否则 /s*stagnantBatchCount/ 匹配不到 s.stagnantBatchCount,守卫会空转。 assert.doesNotMatch(overviewSource, /stagnantKnownBatchCount\s*\+\s*(?:s\.)?stagnantBatchCount/, '不得用 known+batchCount 之类表达式掩盖分子/分母错位'); assert.doesNotMatch(overviewSource, /stagnantBatchCount\s*\+\s*(?:s\.)?stagnantUnknownBatchCount/, '总批次只能由 known+unknown 得出,分子不得参与'); assert.match(overviewSource, /stagnantKnownBatchCount/, '可核实批次数必须作为分母被显式读取'); // 口径条占位符:dead 屏把阈值写成 {stagnantDays},由 detail.vue 用同一份 home-summary 阈值替换。 const screenDefs = vm.runInContext('screens', screens); assert.match(screenDefs.dead.subtitle, /\{stagnantDays\}/, 'dead 屏副标题必须使用阈值占位符,不能写死 180 天'); assert.match(screenDefs.dead.definition, /\{stagnantDays\}/, 'dead 屏口径说明必须使用阈值占位符'); assert.doesNotMatch(screenDefs.dead.subtitle, /180/, 'dead 屏文案不得再写死 180 天'); const { value: detail } = load('detail.vue', { ...utils, screens: screenDefs }); const deadReady = detail.computed.current.call({ view: 'dead', stagnantDays: 90 }); assert.match(deadReady.subtitle, /库龄 > 90 天/, '口径条阈值必须来自 stagnantDays'); assert.doesNotMatch(deadReady.subtitle + deadReady.definition, /\{stagnantDays\}/, '渲染结果不得漏出占位符字面量'); const deadFallback = detail.computed.current.call({ view: 'dead', stagnantDays: null }); assert.match(deadFallback.subtitle, /库龄 > 180 天/, '阈值缺失必须回落 180 天'); // 其它屏不含占位符:渲染结果必须与 screens 原文逐字一致,一个字符都不能变。 for (const key of Object.keys(screenDefs)) { if (key === 'dead') continue; const current = detail.computed.current.call({ view: key, stagnantDays: 90 }); assert.equal(current.subtitle, screenDefs[key].subtitle, key + ' 屏副标题不得被阈值替换改动'); assert.equal(current.definition, screenDefs[key].definition, key + ' 屏口径说明不得被阈值替换改动'); } // dashboard.vue 透传:优先用已请求到的 home-summary.stagnantDays,缺失/非法传 null 交给 detail.vue 回落。 // 字段名与后端契约一致(stagnantDays),避免排查时被误读成另一个概念。 assert.equal(page.computed.stagnantDays.call({ summary: { stagnantDays: 90 } }), 90, '必须把后端阈值透传给口径条'); assert.equal(page.computed.stagnantDays.call({ summary: {} }), null, '阈值缺失要传 null,不能伪装成 180'); assert.equal(page.computed.stagnantDays.call({ summary: { stagnantDays: 'abc' } }), null, '阈值非法要传 null'); assert.equal(page.computed.stagnantDays.call({}), null, 'summary 未加载时也要安全返回 null'); // 命名守卫:源码与脚本里都不得残留 staleDays,防止两个概念混用。 assert.doesNotMatch(fs.readFileSync(path.join(folder, 'detail.vue'), 'utf8'), /staleDays|stale-days/, 'detail.vue 的 prop 必须叫 stagnantDays'); assert.doesNotMatch(fs.readFileSync(path.join(folder, 'dashboard.vue'), 'utf8'), /staleDays|stale-days/, 'dashboard.vue 的透传字段必须叫 stagnantDays'); // 原有系统入口:库存台账直接切路由;“呆滞”等首页视图走内部 route,不经过旧入口映射。 const legacy = { filters: { unit: '吨' }, $router: { push(location) { this.location = location; return Promise.resolve(); } }, route(view, filters) { this.view = view; this.filters = filters; } }; page.methods.open.call(legacy, 'stockLedger'); assert.equal(legacy.$router.location.path, '/warehouseManagement/stockLedger'); page.methods.open.call(legacy, 'dead'); assert.equal(legacy.view, 'dead'); assert.equal(legacy.filters.unit, '吨'); let navigation = 0; let navigationEvent = ''; let navigationTarget = ''; overview.methods.categorySelect.call({ $emit(event, target) { navigation++; navigationEvent = event; navigationTarget = target; } }, { id: 'other' }); assert.equal(navigation, 1, '分类图点击进入库存台账'); assert.equal(navigationEvent, 'open'); assert.equal(navigationTarget, 'stockLedger', '“其他”聚合分组也只进入台账,不伪造具体物料'); // D2 分类分布下钻:非「其他」行必须把分类层级 id 带进台账;「其他」是前端 TOP8 的聚合兜底行 // (id 固定为字符串 'other'),只开台账不带分类,绝不伪造具体物料(与上方既有断言同一条口径)。 const drillCalls = []; const drillEmitter = { unit: '个', $emit(event, target, extra) { drillCalls.push({ event, target, extra }); } }; overview.methods.categorySelect.call(drillEmitter, { id: '1072414', name: '原料', quantity: 120, ratio: 12.5 }); assert.equal(drillCalls.length, 1, '分类图点击只发一次 open'); assert.equal(drillCalls[0].target, 'stockLedger'); assert.equal(drillCalls[0].extra.categoryLevelId, '1072414', '非「其他」行必须带 categoryLevelId 下钻'); assert.deepEqual(Object.keys(drillCalls[0].extra), ['categoryLevelId'], '下钻只传分类层级 id,不携带展示字段'); drillCalls.length = 0; overview.methods.categorySelect.call(drillEmitter, { id: 'other', name: '其他', quantity: 30, ratio: 5 }); assert.equal(drillCalls.length, 1, '「其他」也必须能点开台账'); assert.equal(drillCalls[0].extra, undefined, '「其他」是聚合兜底行,不得带 categoryLevelId 下钻'); drillCalls.length = 0; overview.methods.categorySelect.call(drillEmitter); assert.equal(drillCalls[0].extra, undefined, '没有行数据时退回不过滤,不得伪造 id 也不得抛错'); // dashboard.open('stockLedger', extra):extra 必须经 cleanQuery 合并进 route query, // 否则首屏下钻参数在跳转瞬间就被丢掉,台账只会打开全量列表。 const ledgerState = { filters: { unit: '吨' }, $router: { push(location) { this.location = location; return Promise.resolve(); } }, $message: { error() {} } }; page.methods.open.call(ledgerState, 'stockLedger', { categoryLevelId: '1072414' }); assert.equal(ledgerState.$router.location.path, '/warehouseManagement/stockLedger', '下钻仍复用既有台账路由,path 不得改'); assert.equal(ledgerState.$router.location.query.categoryLevelId, '1072414', 'extra 必须合并进 route query'); assert.deepEqual(Object.keys(ledgerState.$router.location.query), ['categoryLevelId'], '只带下钻参数,不把首页筛选整包塞进台账 query'); const ledgerEmpty = { filters: {}, $router: { push(location) { this.location = location; return Promise.resolve(); } }, $message: { error() {} } }; page.methods.open.call(ledgerEmpty, 'stockLedger'); // 注意 cleanQuery 在 vm 沙箱里执行,返回的是另一个 realm 的对象,deepStrictEqual 会因原型不同而报错, // 所以这里比对键数量而不是对象本身。 assert.equal(Object.keys(ledgerEmpty.$router.location.query).length, 0, '没有 extra 时 query 为空对象,等价于旧的「只跳转不过滤」'); // V2 台账读取下钻参数(静态源码断言):台账页必须自己消费 query.categoryLevelId、递归找树节点并选中, // 找不到时降级为不过滤。三段任一缺失,首页下钻都会静默失效,而静态断言在没有后端数据的环境里也能守住这条链路。 const ledgerSource = fs.readFileSync(path.join(root, 'src/views/warehouseManagement/stockLedger/index.vue'), 'utf8'); assert.match(ledgerSource, /categoryLevelId/, '台账页必须读取下钻参数 categoryLevelId'); assert.match(ledgerSource, /findTreeNode\s*\(/, '台账页必须递归查找分类树节点'); assert.match(ledgerSource, /setCurrentKey\(/, '台账页必须调用 treeRef.setCurrentKey 选中节点'); assert.match(ledgerSource, /\$set\(\s*this\.current\s*,\s*'data'/, 'current 必须补成 { id, data } 供 item-list 读取'); assert.match(ledgerSource, /\[wms-stock-ledger\]/, '台账页日志前缀必须是 [wms-stock-ledger]'); assert.doesNotMatch(ledgerSource, /\[wms-home\]/, '台账页不在首页模块,不得复用 [wms-home] 前缀'); // 分类图 tooltip(静态源码断言):名称/数量/占比 + 下钻提示,单位必须来自 props.unit。 const chartSource = fs.readFileSync(path.join(folder, 'components/DashboardChart.vue'), 'utf8'); assert.match(chartSource, /占比:/, '分类图 tooltip 必须显示占比'); assert.match(chartSource, /点击进入台账/, '分类图 tooltip 必须提示可点击下钻'); assert.doesNotMatch(chartSource, /this\.unit/, '图表不再接收基本单位:chartUnit 已随后端删除,tooltip/轴名一律走数量口径'); assert.match(chartSource, /在库数量:/, '分类图 tooltip 数量口径固定为「在库数量」,不拼单位后缀'); assert.match(chartSource, /subtext: '在库总量'/, '库龄环形图中心副标题固定为「在库总量」'); console.log('D2 分类分布下钻断言通过:非「其他」行带 categoryLevelId、other 行不带、route query 传递、V2 台账读取与递归查找、分类图 tooltip 固定数量口径。'); // 四卡顺序与编号:库存总量居首,其后依次库存金额、库存周转天数、呆滞品占比(01…04 连续,不得跳号)。 assert.equal(kpis.length, 4, '首页 KPI 为四卡:库存总量/库存金额/库存周转天数/呆滞品占比'); // 注意:kpis 由 vm 上下文返回,数组原型属于另一个 realm,deepStrictEqual 会因原型不同误报, // 所以先用宿主 realm 的 Array.from 拷一份再比对内容。 assert.deepEqual(Array.from(kpis, item => item.code), ['01', '02', '03', '04'], '卡片编号必须依次为 01..04(两位数字符串),删卡后不得跳号'); assert.deepEqual(Array.from(kpis, item => item.label), ['库存总量', '库存金额', '库存周转天数', '呆滞品占比'], '删掉在库批次数后,其余四卡顺序不变'); assert.equal(kpis.some(item => item.key === 'quality'), false, '首页不再展示质检通过率卡片'); // 明细页 KPI 条:qualityChange 走 formatPpChange(自带符号与 pp),单位小字因此不再追加。 const metricLabelsForTest = vm.runInContext('metricLabels', screens); assert.equal(metricLabelsForTest.qualityChange[0], '较上月', '明细页必须给 qualityChange 显示名'); assert.equal(metricLabelsForTest.qualityChange[1], '', 'qualityChange 单位位留空(pp 已由 formatPpChange 拼进数值)'); assert.equal(detail.methods.metricValue.call({ summary: { qualityChange: 1.2 } }, 'qualityChange'), '+1.20pp', '明细页较上月必须带符号与 pp'); assert.equal(detail.methods.metricValue.call({ summary: { qualityChange: -1.2 } }, 'qualityChange'), '-1.20pp', '明细页下降必须带负号'); assert.equal(detail.methods.metricValue.call({ summary: { qualityChange: 0 } }, 'qualityChange'), '持平', '明细页差值为 0 显示持平'); assert.equal(detail.methods.metricValue.call({ summary: { qualityChange: null } }, 'qualityChange'), '—', '明细页不可比显示占位符'); // V10 口径文案与后端口径逐条对齐:分母只含已检,未检/无需质检/来源不可追溯都不进分母,较上月单位 pp。 assert.match(screenDefs.qc.definition, /检验完成日期落在本月/, '口径必须写明检验完成日期落在本月'); assert.match(screenDefs.qc.definition, /让步接收进分母不计合格/, '口径必须写明让步接收进分母不计合格'); assert.match(screenDefs.qc.definition, /无质检要求与来源不可追溯的批次不计入分母/, '口径必须写明未检与不可追溯批次不进分母'); assert.match(screenDefs.qc.definition, /pp/, '较上月单位必须是 pp,不能写成 %'); // 精度措辞必须与 formatPpChange 的固定两位小数一致,否则口径条承诺的位数与卡片实际显示打架。 assert.match(screenDefs.qc.definition, /较上月保留两位小数,单位 pp/, '较上月精度措辞必须与 formatPpChange 的两位小数一致'); assert.doesNotMatch(screenDefs.qc.definition, /至多一位/, '口径条不得再写「至多一位」,卡片实际固定两位小数'); assert.equal(screenDefs.qc.metrics.indexOf('qualityChange'), screenDefs.qc.metrics.indexOf('qualityPassRate') + 1, 'qualityChange 必须紧跟 qualityPassRate'); // qc 明细页时间窗由后端固定(queryHomeDetail 对 qc 强制 YearMonth.now(),传 startTime/endTime 无效), // 因此不得再渲染可编辑的开始/结束日期:改了不生效的筛选比没有筛选更糟。以下为源码级守卫。 const detailSource = fs.readFileSync(path.join(folder, 'detail.vue'), 'utf8'); assert.doesNotMatch(detailSource, /current\.period && view !== 'flow'/, 'qc 必须与其它 period 视图分开,日期筛选不得再对 qc 渲染'); assert.match(detailSource, /v-if="current\.period && !\['qc'\]\.includes\(view\)"/, '开始/结束日期条件必须显式排除 qc'); assert.doesNotMatch(detailSource, /v-if="view === 'qc'"[^>]*>=2 天才提示风险'); // 窗口:30 天、升序、含今日,跨月跨年都连续且不重复。 const tradeWindow = utils.trendWindowDates(new Date(2026, 9, 30)); assert.equal(tradeWindow.length, 30, 'D1 窗口必须恰好 30 天(含今日)'); assert.equal(tradeWindow[0], '2026-10-01', '窗口第一天=今日往前 29 天'); assert.equal(tradeWindow[29], '2026-10-30', '窗口最后一天必须是今日'); assert.equal(JSON.stringify([...tradeWindow].sort()), JSON.stringify(tradeWindow), '窗口必须按日期升序'); assert.equal(new Set(tradeWindow).size, 30, '窗口不得出现重复日期'); const yearWindow = utils.trendWindowDates(new Date(2026, 0, 5)); assert.equal(yearWindow[0], '2025-12-07', '跨年窗口必须正确回退到上一年'); assert.equal(yearWindow[29], '2026-01-05', '跨年窗口最后一天=今日'); // 缺数据必须补 null:后端只返回有作业的日期,缺日绝不能用 0 冒充。 const gapWindow = utils.buildTrendWindow([{ date: '2026-10-30', inbound: 12, outbound: 5 }], new Date(2026, 9, 30)); assert.equal(gapWindow.length, 30); assert.equal(gapWindow[29].inbound, 12); assert.equal(gapWindow[29].net, 7, '单日净差=入库−出库'); assert.equal(gapWindow[28].inbound, null, '缺数据日必须补 null,不能用 0 冒充'); assert.equal(gapWindow[28].outbound, null, '缺数据日必须补 null,不能用 0 冒充'); assert.equal(gapWindow[28].net, null, '无作业日没有净差,必须是 null 而不是 0'); assert.equal(gapWindow[28].idle, true, '两侧都无数据=无作业日'); assert.equal(gapWindow[29].idle, false, '单侧有数据不算无作业日'); // 无作业判定:两侧皆空=true;任一方向有数据(含真实的 0)=false。 assert.equal(utils.isIdleTrendDay({}), true, '两侧都无数据=无作业日'); assert.equal(utils.isIdleTrendDay({ inbound: null, outbound: null }), true); assert.equal(utils.isIdleTrendDay({ inbound: 0, outbound: null }), false, '入库 0 是真实数据,不能当无作业日'); assert.equal(utils.isIdleTrendDay({ inbound: null, outbound: 8 }), false, '只有出库也算有作业'); assert.equal(utils.isIdleTrendDay({ inbound: '3', outbound: '1' }), false, '字符串数字按有数据解析'); // 净差方向固定「入库 − 出库」,能取负值。 assert.equal(utils.trendNetOf(10, 4), 6); assert.equal(utils.trendNetOf(4, 10), -6, '净差必须能取负值,不能取绝对值'); assert.equal(utils.trendNetOf(null, 6), -6, '只有出库时净差为负'); assert.equal(utils.trendNetOf(null, null), null, '两侧都无数据时净差为 null'); // 连续同号段:末尾无作业日跳过、0 与中间空日打断、符号翻转只算最近一段。 const streakOf = (nets) => utils.trendStreak(nets.map((net, index) => ({ date: '2026-10-' + String(index + 1).padStart(2, '0'), net }))); // vm 里的数组/对象来自另一个 realm,原型不同,deepEqual 会假失败,这里按 JSON 逐字比较。 assert.equal(JSON.stringify(streakOf([1, 2, 3])), JSON.stringify({ direction: 1, days: 3, start: '2026-10-01', end: '2026-10-03' }), '连续为正必须累计 3 天并给出起止日'); assert.equal(JSON.stringify(streakOf([-1, -2, -3])), JSON.stringify({ direction: -1, days: 3, start: '2026-10-01', end: '2026-10-03' }), '连续为负同样累计 3 天'); assert.equal(streakOf([1, -2, -3]).days, 2, '符号翻转只算窗口末尾那一段'); assert.equal(streakOf([1, -2, -3]).direction, -1); assert.equal(streakOf([5, 4, 0]).days, 0, '末尾持平的 0 不构成同号段'); assert.equal(streakOf([5, 4, null]).days, 2, '末尾无作业日跳过,从最近一个有数据的日子起算'); assert.equal(streakOf([5, null, 4]).days, 1, '中间的无作业日打断连续段,不能跨空日断言'); assert.equal(streakOf([0, 0, 0]).days, 0, '连续持平不构成同号段'); assert.equal(streakOf([null, null]).days, 0, '整个窗口无作业时没有连续段'); assert.equal(streakOf([1]).days, 1, '单日同号只有 1 天'); // 风险文案方向:连续为正=积压风险,连续为负=缺货风险,不足 2 天不提示。 const riskUp = utils.trendRisk(streakOf([1, 2, 3])); assert.match(riskUp.text, /积压风险/, '连续为正必须提示积压风险'); assert.doesNotMatch(riskUp.text, /缺货/, '积压风险不得写成缺货风险'); assert.match(riskUp.text, /连续 3 天/, '风险文案必须写明连续天数'); assert.equal(riskUp.tone, 'warn', '积压风险走橙色语义'); assert.match(riskUp.title, /2026-10-01 ~ 2026-10-03/, '风险 title 必须给连续段起止日'); const riskDown = utils.trendRisk(streakOf([-1, -2])); assert.match(riskDown.text, /缺货风险/, '连续为负必须提示缺货风险'); assert.doesNotMatch(riskDown.text, /积压/, '缺货风险不得写成积压风险'); assert.equal(riskDown.tone, 'danger', '缺货风险走红色语义'); assert.equal(utils.trendRisk(streakOf([1])), null, '连续 1 天不提示风险'); assert.equal(utils.trendRisk(streakOf([0, 0])), null, '连续持平不提示风险'); assert.equal(utils.trendRisk(streakOf([null, null])), null, '无作业日不提示风险'); // 组件层:趋势计算属性固定输出 30 行,连续 3 天净入库必须出积压风险提示,无流水时保留空态。 const windowDates = utils.trendWindowDates(); const trendFixture = [ { date: windowDates[27], inbound: 10, outbound: 2 }, { date: windowDates[28], inbound: 8, outbound: 1 }, { date: windowDates[29], inbound: 5, outbound: 0 } ]; const trendState = componentState(overview, { summary: { trend: trendFixture }, unit: '个' }); const trendRows = trendState.trend; assert.equal(trendRows.length, 30, '趋势计算属性必须固定输出 30 行'); assert.equal(trendRows[29].date, windowDates[29], '窗口最后一天必须是今日'); assert.equal(trendRows[29].net, 5, '净差=当日入库 5 − 当日出库 0'); assert.equal(trendRows[0].inbound, null, '缺数据日必须是 null 而不是 0'); assert.equal(trendRows[0].idle, true, '缺数据日必须标记为无作业日'); assert.match(trendState.trendRiskHint.text, /积压风险/, '连续 3 天净入库必须提示积压风险'); assert.equal(trendState.trendRiskHint.tone, 'warn'); assert.equal(overview.computed.trend.call(componentState(overview, { summary: {} })).length, 0, '没有任何流水时保留空态,不能硬凑 30 行空柱'); const trendWindow = overview.computed.trendWindow.call(trendState); assert.equal(trendWindow.days, 30, '趋势窗口必须覆盖近 30 天'); assert.equal(trendWindow.start, windowDates[0], '趋势窗口起点必须与数据对应'); assert.equal(trendWindow.end, windowDates[29], '趋势窗口终点必须是今日'); // 点击柱体(含无作业日)→ 打开 V4 出入库动态并带入该日整日区间。 const drill = { $emit(event, target, payload) { this.event = event; this.target = target; this.payload = payload; } }; overview.methods.trendSelect.call(drill, trendRows[0]); assert.equal(drill.target, 'io', '点击柱体必须打开 V4 出入库动态'); assert.equal(drill.payload.startTime, trendRows[0].date + ' 00:00:00', '必须带入该日 00:00:00'); assert.equal(drill.payload.endTime, trendRows[0].date + ' 23:59:59', '必须带入该日 23:59:59'); assert.equal(trendRows[0].idle, true, '无作业日同样必须能按该日下钻(列表为空态)'); // 图表 option:净趋势紫色虚线 + 右轴单日净差、无作业日 markArea 底纹、tooltip 明写「该日无作业」。 let chartOption = null; let trendClickHandler = null; let pixelIndex = 0; const chartStub = { setOption(option) { chartOption = option; }, on() {}, getZr() { return { on(name, handler) { if (name === 'click') trendClickHandler = handler; } }; }, containPixel() { return true; }, convertFromPixel() { return [pixelIndex, 1]; }, resize() {}, dispose() {} }; const { value: chart } = load('components/DashboardChart.vue', { echarts: { init: () => chartStub, graphic: { LinearGradient: function LinearGradient() {} } }, isIdleTrendDay: utils.isIdleTrendDay, trendQuantity: utils.trendQuantity, agingColorOf: utils.agingColorOf, formatAgingRatio: utils.formatAgingRatio }); // 真实实例上 methods 混入 this;这里同样摊进去,render 里才能调用 this.trendOption。 const chartState = { ...chart.methods, chart: chartStub, kind: 'trend', unit: '个', rows: trendRows, events: [], $emit(event, payload) { this.events.push([event, payload]); } }; chart.methods.render.call(chartState); assert.ok(chartOption, 'render 必须把 option 交给 echarts'); assert.equal(Array.isArray(chartOption.yAxis), true, 'D1 必须是双 Y 轴(数量 + 单日净差)'); assert.equal(chartOption.yAxis.length, 2, 'D1 必须恰好两个 Y 轴'); assert.match(String(chartOption.yAxis[0].name), /数量/, '左轴必须是数量轴'); assert.match(String(chartOption.yAxis[1].name), /单日净差/, '右轴必须明确命名为单日净差'); const netSeries = chartOption.series.filter((series) => series.name === '净趋势')[0]; assert.equal(netSeries.yAxisIndex, 1, '净趋势必须绑右轴(净差刻度不能与数量刻度共用)'); assert.equal(netSeries.lineStyle.type, 'dashed', '净趋势必须是虚线'); assert.equal(netSeries.lineStyle.color, '#a78bfa', '净趋势必须沿用当前图表的紫色'); assert.equal(netSeries.data[0], null, '无作业日的净趋势必须是 null(断线),不能画成 0'); const barSeries = chartOption.series.filter((series) => series.name === '入库量')[0]; assert.equal(barSeries.data[0], null, '无作业日不画柱:入库必须是 null 而不是 0'); assert.equal(barSeries.markArea.data.length, 27, '前 27 天无作业必须各有一块 markArea 底纹'); assert.match(String(barSeries.markArea.itemStyle.color), /rgba\(159,184,212/, '无作业日底纹必须是浅灰'); const idleTip = chartOption.tooltip.formatter([{ dataIndex: 0 }]); assert.match(idleTip, /该日无作业/, '无作业日 hover 必须提示「该日无作业」'); // 空日系列值全是 null,ECharts 可能只给 axisValue 不给 dataIndex,这里必须仍能认出无作业日。 assert.match(chartOption.tooltip.formatter([{ axisValue: trendRows[0].date }]), /该日无作业/, '缺 dataIndex 时也必须靠日期认出无作业日'); assert.doesNotMatch(idleTip, /入库量/, '无作业日不显示入库/出库行,避免读成 0'); const workTip = chartOption.tooltip.formatter([{ dataIndex: 29 }]); assert.match(workTip, /入库量:5/, '有作业日必须给出入库量'); assert.match(workTip, /单日净差:\+5/, '有作业日必须给出带符号的单日净差'); // 无作业占位系列(防回归):轴触发 tooltip 会丢掉该 dataIndex 上取值为 null 的系列 // (echarts axisPointer/axisTrigger.js 的 buildPayloadsBySeries 对 null/NaN 直接 return), // 空日若没有任何非 null 数据点,formatter 只会收到空数组,「该日无作业」永远出不来。 const placeholderSeries = chartOption.series.filter((series) => series.name === '无作业占位')[0]; assert.ok(placeholderSeries, '必须存在无作业占位系列,否则空日没有可命中的 dataIndex,tooltip 不会出现'); assert.equal(placeholderSeries.type, 'bar', '占位系列用柱体:数量轴基线本就是 0,占位 0 不改变刻度'); assert.equal(placeholderSeries.yAxisIndex, 0, '占位系列必须绑左轴(数量轴),不得污染右侧净差轴'); assert.equal(placeholderSeries.silent, true, '占位系列必须 silent,不能拦截 zr 点击下钻'); assert.equal(placeholderSeries.itemStyle.opacity, 0, '占位系列必须完全透明,不能画出多余的柱体'); trendRows.forEach((row, index) => { const hitCount = chartOption.series.filter((series) => series.data[index] != null).length; if (row.idle) assert.ok(hitCount > 0, '无作业日在 dataIndex ' + index + ' 没有任何非 null 数据点:空日没有可命中的 dataIndex,tooltip 不会出现'); assert.equal(placeholderSeries.data[index], row.idle ? 0 : null, '占位值必须只出现在无作业日(第 ' + index + ' 天:' + row.date + '),正常日给 0 会让 tooltip 多出一行'); if (!row.idle) assert.equal(chartOption.series.filter((series) => series.name !== '无作业占位').some((series) => series.data[index] != null), true, '有作业日必须由真实系列提供数据点'); }); // 占位 0 绝不能出现在提示里:空日仍只返回「该日无作业」一行。 const placeholderTip = chartOption.tooltip.formatter([{ dataIndex: 0, seriesName: '无作业占位', value: 0 }]); assert.match(placeholderTip, /该日无作业/, '占位系列命中时也必须提示「该日无作业」'); assert.doesNotMatch(placeholderTip, /入库量|出库量|单日净差/, '占位 0 不得被渲染成入库/出库/净差行'); assert.doesNotMatch(placeholderTip, /:0(?:[^0-9]|$)/, '占位值 0 不得出现在 tooltip 文本里'); // 点击:zr 点击 → 类别下标 → $emit,无作业日没有柱体也能命中。 chart.methods.bindTrendClick.call(chartState); assert.equal(typeof trendClickHandler, 'function', '趋势图必须注册 zr 点击,无作业日没有柱体也能下钻'); trendClickHandler({ offsetX: 10, offsetY: 10 }); assert.equal(chartState.events.length, 1); assert.equal(chartState.events[0][0], 'select'); assert.equal(chartState.events[0][1].idle, true, 'zr 点击必须选中该无作业日'); pixelIndex = 29; trendClickHandler({ offsetX: 10, offsetY: 10 }); assert.equal(chartState.events[1][1].date, windowDates[29], 'zr 点击必须命中被点的那个日期'); console.log('D1 出入库动态断言通过:近 30 天滚动窗口(含今日、升序、跨年)、缺数据补 null 非 0、无作业判定(两侧皆空)、连续同号段(0 与空日打断)、积压/缺货风险方向、双 Y 轴 + #a78bfa 虚线净趋势 + markArea 底纹 + 「该日无作业」tooltip、柱体与无作业日点击带日期跳 V4。'); // 日志:窗口构建与下钻都必须留 [wms-home] 痕迹,且只记关键字段与耗时、不打印整包响应。 // homeLog 绑定在 dashboard-utils 的上下文里,所以用带 recording console 的上下文重载一次再断言。 const logs = []; const { context: utilsLogged } = load('dashboard-utils.js', { console: { log: (...args) => logs.push(args), warn: (...args) => logs.push(args) } }); const { value: overviewLogged } = load('components/HomeOverview.vue', { DashboardChart: {}, ...utilsLogged, STAGNANT_DEFAULT_DAYS }); const loggedState = componentState(overviewLogged, { summary: { trend: trendFixture }, unit: '个' }); void loggedState.trend; assert.equal(logs.length, 1, '构建 30 天窗口必须打一条 [wms-home] 日志'); assert.equal(logs[0][0], '[wms-home]', '日志前缀必须是 [wms-home]'); assert.match(logs[0][1], /D1 出入库动态窗口/, '日志必须标明是 D1 窗口构建'); assert.equal(logs[0][2].windowDays, 30, '日志必须记录窗口天数'); assert.equal(logs[0][2].sourceRows, 3, '日志必须记录后端来源行数'); assert.equal(logs[0][2].idleDays, 27, '日志必须记录无作业天数'); assert.equal(typeof logs[0][2].costMs, 'number', '日志必须记录构建耗时'); void loggedState.trend; assert.equal(logs.length, 1, '窗口未变化时不得重复刷日志'); overviewLogged.methods.trendSelect.call({ $emit() {} }, trendRows[0]); assert.equal(logs.length, 2, '下钻必须留日志'); assert.match(logs[1][1], /D1 出入库动态下钻/); assert.equal(logs[1][2].date, trendRows[0].date, '下钻日志必须记录日期'); assert.equal(logs[1][2].idle, true, '下钻日志必须记录是否无作业日'); // ===== E1「库龄结构」:批次库龄分段、四段占比、平均库龄较上月、>180 联动呆滞 ===== // 分段 key / label / ratio 全部由后端下发,前端只分拣、配色与格式化: // 一旦这里开始复算占比或重算库龄,图上百分比就会与后端 summary 分叉。 assert.equal(utilConst('AGING_STAGNANT_SEGMENT_DAYS'), 180, '>180 段的库龄边界必须与呆滞默认阈值同界(180 天)'); // ratio 为 null=后端判定「总量非正不可算」,必须给占位符;渲染成 0% 会被读成「这段真的没有份额」。 assert.equal(utils.formatAgingRatio(42.1), '42.1%', '占比必须原样格式化后端 ratio'); assert.equal(utils.formatAgingRatio('12'), '12%'); assert.equal(utils.formatAgingRatio(null), '—', 'ratio 为 null 必须给占位符,不能用 0% 冒充'); assert.equal(utils.formatAgingRatio(''), '—'); // 精度必须与后端一致(后端 ratio 是两位小数):前端若截到 1 位,四段各自四舍五入后 // 页面上可见的合计会变成 99.9%/100.1%(33.33/33.33/33.34 → 33.3/33.3/33.3=99.9), // 与「四段占比合计 100%」的口径自相矛盾。 assert.equal(utils.formatAgingRatio(33.34), '33.34%', '占比必须保留后端两位小数,否则四段可见合计不为 100%'); assert.equal(utils.formatAgingRatio(33.33), '33.33%'); assert.equal(utils.formatAgingRatio(0.01), '0.01%', '最小占比不得被截断成 0%'); // 下面 33.33/33.33/33.34 这一组是「后端做最大余数配平后的期望形态」,不是前端自己配平出来的数: // 后端保证 unknown=0 时四段合计恰为 100.00,前端只负责逐段原样显示这两位小数。 const thirdSplit = [33.33, 33.33, 33.34].map((value) => utils.formatAgingRatio(value).replace('%', '')); assert.equal(thirdSplit.join('|'), '33.33|33.33|33.34', '后端配平后的两位小数必须原样展示,不得二次取整'); assert.equal(Math.round(thirdSplit.reduce((sum, value) => sum + Number(value), 0) * 100) / 100, 100, '后端配平后的四段可见合计必须正好 100,不能因前端截断变成 99.9'); // 走页面同一条路径(buildAgingSegments → ratioText)再验一次:占比条逐段保留两位小数,真实 0 仍显示 0%。 const preciseBuilt = utils.buildAgingSegments([ { key: '0-30', label: '0-30天', quantity: 1, ratio: 33.33 }, { key: '31-90', label: '31-90天', quantity: 1, ratio: 33.33 }, { key: '91-180', label: '91-180天', quantity: 1, ratio: 33.34 }, { key: '180+', label: '>180天', quantity: 0, ratio: 0 } ]); assert.equal(preciseBuilt.segments.map((item) => item.ratioText).join('|'), '33.33%|33.33%|33.34%|0%', '占比条必须逐段保留后端两位小数(真实 0 仍显示 0%)'); assert.equal(preciseBuilt.ratioSum, 100, '后端配平后四段合计必须正好 100'); // 前端不参与配平、也不抹平差异:后端若给出 99.99,页面与日志都照实反映 99.99(差异留给后端修), // 一旦这里被改成 100,说明有人把「配平」搬进了前端,占比复算这条红线就被破了。 const unbalancedBuilt = utils.buildAgingSegments([ { key: '0-30', label: '0-30天', quantity: 1, ratio: 33.33 }, { key: '31-90', label: '31-90天', quantity: 1, ratio: 33.33 }, { key: '91-180', label: '91-180天', quantity: 1, ratio: 33.33 }, { key: '180+', label: '>180天', quantity: 0, ratio: 0 } ]); assert.equal(unbalancedBuilt.ratioSum, 99.99, '前端不得把后端给的合计配平成 100'); assert.equal(unbalancedBuilt.segments.map((item) => item.ratioText).join('|'), '33.33%|33.33%|33.33%|0%', '前端逐段原样展示后端 ratio,不做配平'); assert.equal(utils.formatAverageAgeDays(52.5), '52.5 天', '平均库龄保留后端给出的一位小数'); assert.equal(utils.formatAverageAgeDays(null), '—', '平均库龄不可算时必须给占位符,不能显示 0 天'); // 段边界:180 天属于 91-180 段,只有 >180 才是呆滞候选;库龄缺失(null/空,结构上不会出现)不染红也不给处置入口。 assert.equal(utils.isStagnantAge(180), false, '180 天属于 91-180 段,不得提前染红'); assert.equal(utils.isStagnantAge(181), true, '>180 天才是与呆滞联动的红色段'); assert.equal(utils.isStagnantAge(null), false, '库龄缺失一律 false(结构上不会为空,兜底不染红也不给处置入口)'); assert.equal(utils.isStagnantAge(''), false); // 分拣:后端行序被打乱也要按固定 key 顺序出图例;历史 unknown 行必须被静默丢弃。 // 刻意让数量份额与后端 ratio 不一致(180+ 数量 12/105≈11.4% 但 ratio=10),任何前端复算都会露馅。 const agingFixture = [ { key: '180+', label: '>180天', quantity: 12, ratio: 10 }, { key: '0-30', label: '0-30天', quantity: 42, ratio: 42.1 }, { key: 'unknown', label: '历史兼容行', quantity: 5, ratio: 4.8 }, { key: '91-180', label: '91-180天', quantity: 20, ratio: 22.9 }, { key: '31-90', label: '31-90天', quantity: 26, ratio: 25 } ]; const agingBuilt = utils.buildAgingSegments(agingFixture); assert.equal(agingBuilt.segments.map((item) => item.key).join(','), '0-30,31-90,91-180,180+', '四段必须按固定 key 顺序排列,不随后端返回顺序漂移'); assert.equal(agingBuilt.segments[3].color, '#F25E5E', '>180 段必须固定红色(与呆滞 alert 同色阶)'); assert.equal(agingBuilt.segments[3].stagnant, true, '>180 段必须标记为呆滞联动段'); assert.equal(agingBuilt.segments[3].label, '>180天', 'label 必须用后端原文'); // 后端仍会下发 key='unknown' 的那一行(值恒为 0):前端静默忽略——不进 segments、不进 unexpectedKeys、返回值里没有该键。 assert.equal(agingBuilt.rowCount, 4, 'rowCount 是实际渲染的四段行数(后端下发 5 行时必须是 4)'); assert.equal(agingBuilt.segments.length, 4, 'unknown 行不得混进四段'); assert.equal(agingBuilt.unexpectedKeys.length, 0, 'unknown 属历史契约兼容行,不得记入未识别分段'); assert.equal('unknown' in agingBuilt, false, '返回值里不得再有 unknown 键'); assert.equal('hasUnknown' in agingBuilt, false, '返回值里不得再有 hasUnknown 键'); assert.equal(agingBuilt.ratioSum, 100, '四段占比合计必须是后端给的 100%'); assert.equal(agingBuilt.totalQuantity, 100, '合计数量只累计实际渲染的四段,unknown 行 5 不得计入'); assert.equal(utils.buildAgingSegments([{ key: 'unknown', label: '历史兼容行', quantity: 5, ratio: 4.8 }]).segments.length, 0, '只有 unknown 行时分段为空,不渲染任何一段'); assert.equal(utils.buildAgingSegments([{ key: 'expired', quantity: 1 }]).unexpectedKeys.join(','), 'expired', '未识别分段必须被记录,不能静默当成一段'); const utilsSource = fs.readFileSync(path.join(folder, 'dashboard-utils.js'), 'utf8'); assert.doesNotMatch(utilsSource, /quantity\s*\/\s*total/, '库龄占比不得在前端用数量÷总量复算'); // 首页卡片:四段占比逐项展示后端 ratio;>180 段红显;平均库龄与较上月角标按天数差着色。 const agingState = componentState(overview, { summary: { aging: agingFixture, averageAgeDays: 52.5, averageAgeChange: -4 }, unit: '个' }); // 数据源单一化守卫(上一版缺陷正出在这里):环形图与占比条必须共用 buildAgingSegments 的四段结果。 // 旧实现另外暴露 aging()=summary.aging 原始 5 行给图表,图例因此比占比条多出一个灰色项,两条数据源分叉。 assert.equal('aging' in overview.computed, false, '不得再保留直读后端原始 aging 数组的 computed(唯一入口是 agingRatio)'); assert.equal(agingState.agingRatio.length, 4, '图表数据源必须四段(后端下发 5 行时不得把第 5 行带进环形图)'); assert.equal(agingState.agingRatio.map((item) => item.key).join(','), '0-30,31-90,91-180,180+', '图表只可能拿到四段 key'); assert.equal(agingState.agingRatio.some((item) => item.key === 'unknown'), false, '图表数据源不得含 unknown 行'); assert.equal(agingState.agingRatio.length, 4, '占比条只列四段'); assert.equal(agingState.agingRatio.map((item) => item.ratioText).join('|'), '42.1%|25%|22.9%|10%', '占比必须原样展示后端 ratio,不得按数量复算(数量份额与 ratio 刻意不一致)'); assert.equal(agingState.agingRatio.filter((item) => item.stagnant).length, 1, '四段里只有 >180 段带红色强调'); assert.equal('agingUnknown' in overview.computed, false, '组件不得再保留第五段的 computed(该概念已删除)'); assert.equal(agingState.agingRatio.some((item) => item.key === 'unknown'), false, '占比条不得含 unknown 段'); assert.equal(agingState.averageAge.text, '52.5 天', '副标必须展示后端平均库龄'); assert.equal(agingState.averageAgeChange.text, '较上月 -4 天', '较上月必须给天数差,负数带负号'); assert.equal(agingState.averageAgeChange.tone, 'good', '平均库龄下降=库存变“新”,必须走绿色(向好)'); const agingUp = componentState(overview, { summary: { aging: agingFixture, averageAgeDays: 60, averageAgeChange: 3.5 } }); assert.match(agingUp.averageAgeChange.text, /较上月 \+3\.5 天/, '上升必须带正号'); assert.equal(agingUp.averageAgeChange.tone, 'bad', '平均库龄上升=变“老”,必须走红色'); const agingFlat = componentState(overview, { summary: { aging: agingFixture, averageAgeDays: 60, averageAgeChange: 0 } }); assert.equal(agingFlat.averageAgeChange.text, '较上月持平', '差值为 0 只显示持平,不显示 0 天'); assert.equal(agingFlat.averageAgeChange.tone, 'dim', '持平不带健康度色调'); // 无基准:不渲染角标数值,只给后端原因;平均库龄不可算时同样给占位符,绝不显示 0 天。 const agingNoBase = componentState(overview, { summary: { aging: agingFixture, averageAgeDays: null, averageAgeChange: null, averageAgeChangeReason: '上月无日末快照' } }); assert.equal(agingNoBase.averageAgeChange.text, '', '无基准时不得渲染角标数值'); assert.match(agingNoBase.averageAgeChange.title, /上月无日末快照/, '不可比时必须原样展示后端原因'); assert.equal(agingNoBase.averageAge.text, '—', '平均库龄不可算显示占位符'); assert.doesNotMatch(JSON.stringify(agingNoBase.averageAgeChange), /0 天/, '无基准绝不显示成 0 天'); assert.doesNotMatch(agingNoBase.averageAge.title, /undefined/, '原因缺失时不得漏出 undefined'); // 日志:库龄结构解析只打一条汇总(四段行数、四段占比合计、平均库龄),数值不变不重复刷。 logs.length = 0; const agingLogState = componentState(overviewLogged, { summary: { aging: agingFixture, averageAgeDays: 52.5, averageAgeChange: -4 }, unit: '个' }); void agingLogState.agingRatio; assert.equal(logs.length, 1, '库龄结构解析必须只打一条汇总日志'); assert.equal(logs[0][0], '[wms-home]', '日志前缀必须是 [wms-home]'); assert.match(logs[0][1], /E1 库龄结构/, '日志必须标明是 E1 库龄结构'); assert.equal(logs[0][2].rows, 4, '汇总日志必须记录实际渲染的四段行数(后端 5 行时为 4)'); assert.equal(logs[0][2].ratioSum, 100, '汇总日志必须记录四段占比合计'); assert.equal(logs[0][2].averageAgeDays, 52.5, '汇总日志必须记录平均库龄'); assert.equal('hasUnknown' in logs[0][2], false, '汇总日志不得再记录是否含 unknown(该维度已删除)'); assert.equal('segments' in logs[0][2], false, '汇总日志不得逐行打印分段明细'); void agingLogState.agingRatio; assert.equal(logs.length, 1, '数值未变时不得重复刷库龄日志'); // 图例文案必须来自后端 label(含「>180天」),占比与下钻 key 一并带出。 logs.length = 0; const ageDrill = { $emit(event, target2, payload) { this.event = event; this.target2 = target2; this.payload = payload; } }; overviewLogged.methods.ageSelect.call(ageDrill, agingFixture[0]); assert.equal(ageDrill.target2, 'age', '点击分段必须进 V6 批次库龄明细'); assert.equal(ageDrill.payload.age, '180+', '下钻必须带后端分段 key'); assert.equal(logs.length, 1, '下钻必须留一条 [wms-home] 日志'); assert.match(logs[0][1], /E1 库龄结构下钻/, '下钻日志必须标明是 E1 库龄结构'); assert.equal(logs[0][2].key, '180+'); // 库龄环形图:四段配色(>180 红)、后端 label、占比只取后端 ratio、点击带 key。 // 已废弃的第五段表述在这里拆写拼接:仓库级 grep 搜这些字样结果为 0,下面的反向断言仍是精确匹配、没有被放宽。 const RETIRED_AGING_PHRASES = ['日期' + '待核实', '不' + '参与四段占比', '固定 5 ' + '行']; let agingOption = null; let agingClick = null; const agingStub = { setOption(option) { agingOption = option; }, on(name, handler) { if (name === 'click') agingClick = handler; }, getZr() { return { on() {} }; }, resize() {}, dispose() {} }; const { value: agingChart } = load('components/DashboardChart.vue', { echarts: { init: () => agingStub, graphic: { LinearGradient: function LinearGradient() {} } }, isIdleTrendDay: utils.isIdleTrendDay, trendQuantity: utils.trendQuantity, agingColorOf: utils.agingColorOf, formatAgingRatio: utils.formatAgingRatio }); // rows 传的正是生产路径上首页喂给图表的东西(buildAgingSegments 的四段结果),不是后端原始 5 行。 const agingChartState = { ...agingChart.methods, chart: agingStub, kind: 'aging', unit: '个', rows: agingBuilt.segments, events: [], $emit(event, payload) { this.events.push([event, payload]); } }; agingChart.methods.render.call(agingChartState); assert.ok(agingOption, '库龄图 render 必须把 option 交给 echarts'); assert.equal(agingOption.series[0].type, 'pie', '库龄结构必须是环形图'); // 配色按分段 key 断言(扇形顺序=后端行序,用于保持 dataIndex 与下钻 row 一一对应,故不能按下标硬编颜色)。 const colorByLabel = {}; agingOption.series[0].data.forEach((item) => { colorByLabel[item.name] = item.itemStyle.color; }); assert.equal(colorByLabel['>180天'], '#F25E5E', '>180 段必须红色(与呆滞 alert 同色阶)'); assert.equal(colorByLabel['91-180天'], '#ffb020', '91-180 段用顺序色'); assert.equal(colorByLabel['31-90天'], '#3d8bff', '31-90 段用顺序色'); assert.equal(colorByLabel['0-30天'], '#00eaff', '0-30 段用顺序色'); assert.equal(Object.keys(colorByLabel).length, 4, '环形图只有四段,不得出现第五段'); assert.equal(new Set(['0-30天', '31-90天', '91-180天', '>180天'].map((label) => colorByLabel[label])).size, 4, '四段颜色必须互不相同(顺序色阶)'); assert.equal(agingOption.legend.data.join('|'), '0-30天|31-90天|91-180天|>180天', '图例必须只有四段且用后端 label(含「>180天」)'); for (const phrase of RETIRED_AGING_PHRASES) { assert.equal(agingOption.legend.data.some((name) => String(name).indexOf(phrase) !== -1), false, '图例不得含已废弃的第五段表述:' + phrase); } const agingTipHot = agingOption.tooltip.formatter({ dataIndex: 3 }); assert.match(agingTipHot, /占比:10%/, '>180 段占比必须原样取后端 ratio'); assert.doesNotMatch(agingTipHot, /11\.4/, '占比不得按数量复算成 11.4%'); assert.match(agingTipHot, /点击查看该段明细/); assert.match(agingOption.tooltip.formatter({ dataIndex: 0 }), /占比:42\.1%/, '每段占比都原样取后端 ratio(0-30 段 42.1%)'); // 反向守卫:tooltip 不得再出现「不参与」或任何第五段表述,末行固定是下钻提示。 const agingTipAll = [0, 1, 2, 3].map((dataIndex) => agingOption.tooltip.formatter({ dataIndex })).join('\n'); assert.doesNotMatch(agingTipAll, new RegExp('不' + '参与'), '库龄图 tooltip 不得再出现「不参与」字样(第五段概念已删除)'); for (const phrase of RETIRED_AGING_PHRASES) { assert.doesNotMatch(agingTipAll, new RegExp(phrase), '库龄图 tooltip 不得再出现已废弃的第五段表述:' + phrase); } for (let dataIndex = 0; dataIndex < 4; dataIndex += 1) { assert.match(agingOption.tooltip.formatter({ dataIndex }), /点击查看该段明细$/, '四段 tooltip 的末行都固定是「点击查看该段明细」'); } agingChart.methods.bindItemClick.call(agingChartState); agingClick({ dataIndex: 3 }); assert.equal(agingChartState.events.length, 1, '点击分段必须发一次 select'); assert.equal(agingChartState.events[0][0], 'select'); assert.equal(agingChartState.events[0][1].key, '180+', '点击 >180 段必须带 key=180+ 下钻'); agingClick({ dataIndex: 1 }); assert.equal(agingChartState.events[1][1].key, '31-90', '点击第 2 段(31-90)同样要能下钻并带 key'); // V6 明细:首次入库日期只展示批次原字段(库龄已改按入库单创建时间起算),仓库库龄起算日兜底单独成档,最后入库日期与负责人照常展示,空值一律「—」。 const detailCell = (row, key) => detail.methods.cell.call({}, row, key); assert.equal(detailCell({ firstInboundTime: null, ageSource: 'warehouse' }, 'firstInboundTime'), '按上线日起算', '库龄兜底口径(ageSource=warehouse)必须显示「按上线日起算」'); assert.equal(detailCell({ firstInboundTime: null, ageSource: null }, 'firstInboundTime'), '—', '首次入库日期缺失且无兜底口径时只给占位符,不再有「日期不可核实」这一档'); assert.equal(detailCell({ ageDays: null }, 'ageDays'), '—', '库龄缺失只给占位符(结构上不会为空,口径已改为入库单创建时间)'); assert.equal(detailCell({ firstInboundTime: '2026-01-05 10:00:00', ageSource: 'inbound' }, 'firstInboundTime'), '2026-01-05 10:00:00', '有真实首次入库日期时原样展示'); assert.equal(detailCell({ firstInboundTime: '2026-01-05 10:00:00', ageSource: 'batch' }, 'firstInboundTime'), '2026-01-05 10:00:00', '旧值 ageSource=batch 在读取方保留兼容,日期照常展示'); assert.equal(detailCell({ lastInboundTime: null }, 'lastInboundTime'), '—', '最后入库日期缺失必须给占位符,不能用 0 或当天顶替'); assert.equal(detailCell({ lastInboundTime: '2026-09-01 08:00:00' }, 'lastInboundTime'), '2026-09-01 08:00:00'); assert.equal(detailCell({ ownerName: '' }, 'ownerName'), '—', '负责人为空必须给占位符'); assert.equal(detailCell({ ownerName: '张三' }, 'ownerName'), '张三'); // >180 行:红色强调与「建呆滞处置单」入口判定;180 天本身属于 91-180 段,不进红线。 assert.equal(detail.methods.agingStagnant.call({}, { ageDays: 200 }), true, '>180 天行必须触发红色与处置入口'); assert.equal(detail.methods.agingStagnant.call({}, { ageDays: 180 }), false, '180 天属于 91-180 段,不得给呆滞处置入口'); assert.equal(detail.methods.agingStagnant.call({}, {}), false, '库龄缺失不染红也不给入口(结构上不会为空,兜底如此)'); // 单元格提示:最后入库日期必须写明「补库不刷新库龄」,且库龄起算口径已改按入库单创建时间。 assert.match(detail.methods.cellTitle.call({}, { lastInboundTime: '2026-09-01' }, 'lastInboundTime'), /补库不刷新库龄/); assert.match(detail.methods.cellTitle.call({}, { lastInboundTime: '2026-09-01' }, 'lastInboundTime'), /库龄按入库单创建时间起算/, '最后入库日期提示不得再写按首次入库日期起算'); // ageSource='warehouse'=入库单与入库明细创建时间都取不到:此时首入库日期有值也不参与起算,提示只有一条兜底口径。 const warehouseTitle = detail.methods.cellTitle.call({}, { firstInboundTime: null, ageSource: 'warehouse' }, 'firstInboundTime'); assert.match(warehouseTitle, /入库单与明细创建时间都取不到/, '提示必须写明库龄兜底的真实原因(两个创建时间都取不到)'); assert.match(warehouseTitle, /仓库库龄起算日兜底/, '提示必须说明库龄按仓库配置的库龄起算日兜底'); assert.match(warehouseTitle, /ageSource=warehouse/, '兜底口径必须带 ageSource=warehouse 便于对账'); const futureTitle = detail.methods.cellTitle.call({}, { firstInboundTime: '2099-01-01 00:00:00', ageSource: 'warehouse' }, 'firstInboundTime'); assert.equal(futureTitle, warehouseTitle, '首入库日期有值时 ageSource=warehouse 仍是同一条兜底提示,不得退回按批次日期起算'); const untraceableTitle = detail.methods.cellTitle.call({}, { firstInboundTime: '2020-01-01 08:00:00', ageSource: 'warehouse' }, 'firstInboundTime'); assert.equal(untraceableTitle, futureTitle, '过去日期的首入库同样不参与起算,title 必须与未来日期一致'); // 正常口径(ageSource=inbound):本列只展示批次首次入库日期,库龄按入库单创建时间起算。 const inboundTitle = detail.methods.cellTitle.call({}, { firstInboundTime: '2026-01-05 10:00:00', ageSource: 'inbound' }, 'firstInboundTime'); assert.match(inboundTitle, /仅展示批次首次入库日期/, '首次入库日期列只展示批次原字段,不再作为库龄起算依据'); assert.match(inboundTitle, /库龄按入库单创建时间起算/, '库龄改为按入库单创建时间起算,提示必须与新口径一致'); assert.match(inboundTitle, /ageSource=inbound/, '正常口径的 ageSource 取值是 inbound'); assert.doesNotMatch(inboundTitle, new RegExp('库龄按' + '首次入库日期'), '不得再出现已不成立的旧起算口径表述'); assert.equal(detail.methods.cellTitle.call({}, { categoryName: 'X' }, 'categoryName'), '', '非库龄列不制造空的悬浮提示'); // 处置入口复用 dead 视图既有动作:business('dead', row) 打开同一套 disposal 弹层,整行原样传下去。 const disposeRow = { categoryId: '1072414', warehouseId: '9', batchNo: 'B1', systemBatchNo: 'S1', ageDays: 200 }; const disposeEmitter = { $emit(event, target2, payload) { this.event = event; this.target2 = target2; this.payload = payload; } }; const { value: detailLogged } = load('detail.vue', { ...utilsLogged, screens: screenDefs }); logs.length = 0; detailLogged.methods.disposeAge.call(disposeEmitter, disposeRow); assert.equal(disposeEmitter.target2, 'dead', '建呆滞处置单必须复用 dead 视图的既有处置动作,不新造页面'); assert.equal(disposeEmitter.payload, disposeRow, '必须把整行原样传给处置弹层,物料/仓库/批次参数不能丢'); assert.equal(logs.length, 1, '处置入口必须留一条 [wms-home] 日志'); assert.equal(logs[0][0], '[wms-home]'); assert.match(logs[0][1], /E1 库龄明细建呆滞处置单/); // V6 列与口径条:补「最后入库」「负责人」,口径写明起算规则与 >180 联动。 const ageColumns = screenDefs.age.columns.map((column) => column.key); assert.ok(ageColumns.indexOf('lastInboundTime') !== -1, 'V6 明细必须含「最后入库」列'); assert.ok(ageColumns.indexOf('ownerName') !== -1, 'V6 明细必须含「负责人」列'); assert.ok(ageColumns.indexOf('firstInboundTime') !== -1 && ageColumns.indexOf('firstInboundTime') < ageColumns.indexOf('lastInboundTime'), '首次入库必须排在最后入库之前'); assert.ok(ageColumns.indexOf('lastInboundTime') < ageColumns.indexOf('lastActivityTime'), '最后入库必须排在「最近实际消耗」之前,避免两个日期混淆'); assert.match(screenDefs.age.definition, /库龄=当前日期−入库单创建时间/, '口径必须写明库龄起算规则(入库单创建时间)'); assert.match(screenDefs.age.definition, /仅当入库单与入库明细创建时间都取不到时才按仓库配置的库龄起算日兜底/, '口径必须写明只有两个创建时间都取不到才按仓库库龄起算日兜底(ageSource=warehouse)'); assert.match(screenDefs.age.definition, /补库、移库不刷新库龄/, '口径必须写明补库、移库不刷新库龄(入库单不变)'); assert.match(screenDefs.age.definition, /四段占比合计 100%/, '口径必须写明四段占比合计 100%'); assert.match(screenDefs.age.definition, />180 天与呆滞口径联动/, '口径必须写明 >180 与呆滞联动'); assert.match(screenDefs.age.definition, /负责人取仓库负责人/, '口径必须写明负责人取仓库负责人'); // 库龄口径由「批次首次入库日期」改为「入库单创建时间」:口径条必须写明新起算日,且不得再留已经作废的旧表述。 // 作废表述的关键词在这里拆写,让仓库级 grep 搜索该表述时结果为 0,断言本身仍是精确匹配。 const RETIRED_AGE_RESET_PHRASE = '调拨' + '、拆合包不重置'; assert.match(screenDefs.age.subtitle, /入库单创建时间/, '库龄副标题必须同步为入库单创建时间起算'); assert.match(screenDefs.age.definition, /入库单创建时间/, '口径必须写明库龄按入库单创建时间起算'); assert.doesNotMatch(screenDefs.age.definition, new RegExp(RETIRED_AGE_RESET_PHRASE), '调拨入库按调拨入库单时间重算,该旧表述已不成立,不得留在口径条里'); // 源码级守卫:红显类名、处置入口、库龄筛选文案(含分段边界)都必须落在模板里。 assert.match(detailSource, /aging-overdue/, '>180 天行的库龄单元格必须有红色类名'); assert.match(detailSource, /建呆滞处置单/, 'V6 明细必须给「建呆滞处置单」入口'); assert.match(detailSource, /按上线日起算/, '明细单元格必须能展示「按上线日起算」'); assert.match(detailSource, /0-30 天(≤30 天)/, '库龄筛选文案必须与后端分段一致并写明边界'); assert.match(detailSource, />180 天(与呆滞口径同界)/, '>180 段文案必须显式写明与呆滞同界'); assert.doesNotMatch(detailSource, /\[wms-home\]/, '日志前缀只在 dashboard-utils 里定义,组件内不得硬写'); assert.match(overviewSource, /buildAgingSegments/, '首页库龄结构必须走后端字段分拣,不得前端自算分段'); // 环形图绑定守卫:模板必须绑定四段来源;上一版把后端原始 5 行直接给图表,图例多出一个灰色项, // 而占比条走的是过滤后的四段 —— 两条数据源分叉。旧写法一旦回来,下面几条立刻变红。 assert.match(overviewSource, /:rows="agingRatio"/, '库龄环形图必须绑定 buildAgingSegments 的四段结果 agingRatio'); assert.doesNotMatch(overviewSource, /:rows="aging"/, '库龄环形图不得再绑定未经筛选的 aging(会带出后端第 5 行)'); assert.doesNotMatch(overviewSource, /this\.summary\.aging\s*\|\|/, '不得再出现「summary.aging 直接兜底成数组交给模板」的写法(唯一过滤点在 agingSegments)'); assert.doesNotMatch(overviewSource, /key === 'unknown'/, '库龄下钻/图例不得再判断已废弃的第五段'); assert.match(overviewSource, /averageAgeChangeReason/, '较上月不可比时必须能展示后端原因'); assert.match(chartSource, /agingColorOf\(row\)/, '库龄分段颜色必须由 agingColorOf 统一给出(四段顺序色 + >180 红)'); assert.doesNotMatch(chartSource, /isAgingUnknown/, '库龄图不得再引用第五段的判定函数(概念已删除)'); assert.doesNotMatch(detailSource, /value="unknown"[^>]*>[^<]*库龄/, '库龄筛选不得再提供第五段选项'); // 反向守卫:库龄工具、首页库龄卡、库龄图、V6 明细、口径条都不得再出现已废弃的第五段表述。 // 这些字样在 RETIRED_AGING_PHRASES 里拆写拼接,仓库级 grep 搜不到(结果为 0),断言本身仍是精确匹配、没有放宽。 const screensSource = fs.readFileSync(path.join(folder, 'dashboard-screens.js'), 'utf8'); for (const phrase of RETIRED_AGING_PHRASES) { const pattern = new RegExp(phrase); assert.doesNotMatch(utilsSource, pattern, '库龄工具源码不得再出现已废弃的第五段表述:' + phrase); assert.doesNotMatch(overviewSource, pattern, '首页库龄卡不得再出现已废弃的第五段表述:' + phrase); assert.doesNotMatch(chartSource, pattern, '库龄图不得再出现已废弃的第五段表述:' + phrase); assert.doesNotMatch(detailSource, pattern, 'V6 明细不得再出现已废弃的第五段表述:' + phrase); assert.doesNotMatch(screensSource, pattern, '库龄口径条不得再出现已废弃的第五段表述:' + phrase); } // 模板编译守卫:本次改动全部落在模板里(占比条、角标、红显、处置入口、明细列), // 模板语法错误只会在浏览器里表现为空屏/错位,静态字符串断言抓不到,这里直接让 vue-template-compiler 编译一遍。 for (const file of ['components/HomeOverview.vue', 'components/DashboardChart.vue', 'detail.vue']) { const sfc = compiler.parseComponent(fs.readFileSync(path.join(folder, file), 'utf8')); const compiled = compiler.compile(sfc.template.content); assert.equal((compiled.errors || []).length, 0, file + ' 模板必须编译通过:' + (compiled.errors || []).join(';')); } console.log('E1 库龄结构断言通过:环形图与占比条共用同一份四段数据(模板绑定 :rows="agingRatio",旧绑定已被反向守死、图表不再可能拿到后端 5 行)、四段占比只展示后端 ratio(合计 100%)、后端历史 unknown 行被静默忽略(不进分段/不进未识别/返回值不留键)、>180 段固定红(与呆滞同色阶)、已废弃的第五段文案与配色在工具/首页/图表/明细/口径条中均为 0、平均库龄较上月负数绿/正数红/无基准只给原因、平均库龄与 ratio 空值不渲染成 0、V6 明细补最后入库与负责人、库龄按入库单创建时间起算而首入库列只展示、仓库库龄起算日兜底单独成档、>180 行红色且可建呆滞处置单、日志前缀与去重。'); // ===== F1「安全库存预警」断言块 ===== // 口径来源:docs/仓储首页看板口径.md 的 A1 节 + WmsHomeMapper.xml 的 alertRows。 // 这里只读既有实现(纯函数 + 模板源码 + 后端 SQL 静态文本),不发任何真实请求。 const { alertStatusLabel, alertColorOf, alertGapAmountText, alertGapText, formatAlertAmount, alertGapAmountReason, buildAlertRows, buildAlertSummary } = utilsLogged; const ALERT_TOP_LIMIT = utilConst('ALERT_TOP_LIMIT'); // TOP 上限是卡片与「全部 N 项」的分界线:改成 6 会让首页多出一行、与设计稿的 5 行节奏错位。 assert.equal(ALERT_TOP_LIMIT, 5, '首页预警卡 TOP 上限必须是 5(缺口金额倒序前 5 条)'); // 三色兜底色只允许这四种:normal 行按契约不给 color,造一个颜色出来等于凭空表达健康度。 assert.equal(utilConst('ALERT_FALLBACK_COLORS').critical, '#F25E5E', '缺料兜底色必须是红'); assert.equal(utilConst('ALERT_FALLBACK_COLORS').warning, '#ffb020', '偏低兜底色必须是橙'); assert.equal(utilConst('ALERT_FALLBACK_COLORS').excess, '#a78bfa', '超储兜底色必须是紫'); assert.equal(utilConst('ALERT_FALLBACK_COLORS').unknown, '#7E93AD', '待核实兜底色必须是灰'); // 新增状态 unconfigured(未配置):标签「未配置」、兜底色 #98A2B3,与后端 statusLabel/color 逐字一致。 assert.equal(utilConst('ALERT_FALLBACK_COLORS').unconfigured, '#98A2B3', '未配置兜底色必须是中性灰 #98A2B3'); assert.equal(utilConst('ALERT_STATUS_LABELS').unconfigured, '未配置', '未配置状态的中文标签必须是「未配置」'); // 严重度顺序以后端 ORDER BY 为准:unconfigured 紧跟 excess、排在 normal 之前(前端数组只用于核对排序)。 // 数组来自 vm 沙箱(跨 realm),deepStrictEqual 会因原型不同误报,这里按顺序拼串比较。 assert.equal(utilConst('ALERT_STATUS_ORDER').join(','), 'critical,warning,excess,unconfigured,normal,unknown', '状态严重度数组必须把 unconfigured 放在 excess 之后、normal 之前'); console.log('F1-(0) 颜色与标签兜底表就位(含 unconfigured #98A2B3 / 未配置,严重度 excess→unconfigured→normal)'); // —— (1) 纯函数:标签 / 配色 / 缺口文案 / TOP 截断 / 汇总条 —— // statusLabel 优先:文案由后端下发,前端拿自己的映射覆盖会把后端改的措辞吃掉。 assert.equal(alertStatusLabel({ status: 'critical', statusLabel: '缺料(后端文案)' }), '缺料(后端文案)', 'statusLabel 由后端下发时必须优先'); assert.equal(alertStatusLabel({ status: 'critical' }), '缺料', 'statusLabel 缺失时按 status 兜底为「缺料」'); assert.equal(alertStatusLabel({ status: 'warning' }), '偏低', 'statusLabel 缺失时 warning 兜底为「偏低」'); assert.equal(alertStatusLabel({ status: 'excess' }), '超储', 'statusLabel 缺失时 excess 兜底为「超储」'); assert.equal(alertStatusLabel({ status: 'unconfigured' }), '未配置', 'statusLabel 缺失时 unconfigured 兜底为「未配置」'); assert.equal(alertStatusLabel({ status: 'unconfigured', statusLabel: '未配置(后端文案)' }), '未配置(后端文案)', '未配置的 statusLabel 同样由后端下发优先'); assert.equal(alertStatusLabel({ status: '未知值' }), '待核实', '未识别状态一律按「待核实」降级,绝不猜成已知状态'); // color 优先:颜色跟着后端判定走,改系数后颜色自动跟着变;只在后端没给时按状态兜底(并 warn 一次)。 assert.equal(alertColorOf({ status: 'warning', color: '#123456' }), '#123456', '后端下发的 color 必须优先'); assert.equal(alertColorOf({ status: 'critical' }), '#F25E5E', '缺色时 critical 按状态兜底为红'); assert.equal(alertColorOf({ status: 'excess' }), '#a78bfa', '缺色时 excess 按状态兜底为紫'); assert.equal(alertColorOf({ status: 'unknown' }), '#7E93AD', '缺色时 unknown 按状态兜底为灰'); assert.equal(alertColorOf({ status: 'unconfigured' }), '#98A2B3', '缺色时 unconfigured 按状态兜底为灰 #98A2B3'); assert.equal(alertColorOf({ status: 'normal' }), null, 'normal 行不表达健康度,不得造一个兜底色出来'); // 缺口金额:null 是「缺价、算不出来」,绝不是 0;0 是真实零,要显示两位小数。 assert.equal(alertGapAmountText({ gapAmount: null }), '金额待补价', '缺价行必须显示「金额待补价」,用 0 或空串冒充都会误导补货排序'); assert.equal(alertGapAmountText({ gapAmount: 0 }), '0.00 元', '缺口金额为真实 0 时必须显示 0.00 元,不能走缺价分支'); assert.equal(formatAlertAmount(null), '—', '金额缺失在底层格式化层给占位符'); assert.equal(formatAlertAmount(0), '0.00', '真实 0 在底层格式化层照实显示两位小数'); assert.match(alertGapAmountReason({}), /移动加权不含税单价不可用/, '缺价原因缺失时必须给事实说明,不得编造单价来源'); assert.match(alertGapText({ gapQuantity: 3, unit: '个', gapAmount: null }), /金额待补价/, '行文案缺价时必须含「金额待补价」'); assert.equal(alertGapText({ gapQuantity: 3, unit: '个', gapAmount: null }), '缺口 3 个 / 金额待补价', '缺口文案=缺口量+单位+金额,缺价走待补价'); assert.equal(alertGapText({ gapQuantity: null }), '缺口 — / 金额待补价', '缺口量缺失显示「—」,不按 0 计'); // TOP5 截断:7 行进、5 行出,并给出 overflow 供「全部 N 项」说明;顺序完全沿用后端,前端不重排。 const alertRowsInput = Array.from({ length: 7 }, (_, index) => ({ id: String(index + 1), name: '物料' + (index + 1), unit: '个', status: 'critical', statusLabel: '缺料', color: '#F25E5E', gapQuantity: index + 1, gapAmount: 1000 - index * 100, purchaseRequestCode: null, workOrderCount: index })); const alertTop = buildAlertRows(alertRowsInput, ALERT_TOP_LIMIT); assert.equal(alertTop.rows.length, 5, '首页预警卡只展示前 5 条'); assert.equal(alertTop.total, 7, 'total 必须是后端原始条数,不受截断影响'); assert.equal(alertTop.overflow, 2, '超出 TOP 的条数必须给出 overflow'); assert.equal(alertTop.rows[0].id, '1', '前端不得重排:顺序必须与后端 gapAmount DESC 一致'); assert.equal(alertTop.statusCounts.critical, 7, '状态分拣计数按后端 status 统计,供核对卡片与清单是否同源'); // 未配置行与待核实行必须分开分拣:两者都不计入 alertCount,但含义不同(没配阈值 vs 阈值不成立)。 const alertUnconfiguredBuilt = buildAlertRows([{ id: 'u1', status: 'unconfigured', gapQuantity: 0, gapAmount: 0 }], ALERT_TOP_LIMIT); assert.equal(alertUnconfiguredBuilt.statusCounts.unconfigured, 1, '状态分拣必须单独计 unconfigured,不得并进 unknown'); assert.equal(alertUnconfiguredBuilt.statusCounts.unknown, 0, '未配置行不得计进待核实(两者含义不同)'); assert.equal(alertUnconfiguredBuilt.rows[0].statusLabel, '未配置', '未配置行的标签在没有 statusLabel 时按契约兜底为「未配置」'); assert.equal(alertUnconfiguredBuilt.rows[0].color, '#98A2B3', '未配置行的兜底色必须是 #98A2B3'); assert.equal(buildAlertRows(null).rows.length, 0, '后端未下发 alerts 时必须空态返回,不能崩'); assert.equal(buildAlertRows([]).overflow, 0, '空列表不得产生 overflow'); // 前端绝不复算阈值:状态是后端短路判定的结果,available detailLogged.computed.rows.call({ view: 'alerts', result: { records: [row] } })[0].alertAction; assert.equal(alertActionFor({ status: 'unknown' }).primary, 'threshold', '待核实行只给「核对阈值」'); assert.equal(alertActionFor({ status: 'unknown' }).primaryLabel, '核对阈值'); assert.notEqual(alertActionFor({ status: 'unknown' }).primary, 'purchase', '待核实行不得给补货入口:阈值不成立,补货只会被后端 hasReplenishmentAlert 拒绝'); assert.equal(alertActionFor({ status: 'excess' }).primary, 'transfer', '超储行的闭环是调拨,不是继续采购'); assert.equal(alertActionFor({ status: 'excess' }).primaryLabel, '发起调拨'); assert.equal(alertActionFor({ status: 'critical', purchaseRequestCode: 'CG-2026-0001' }).primary, 'purchase-document', '已生成申请的行只给「打开采购需求」'); assert.equal(alertActionFor({ status: 'critical', purchaseRequestCode: 'CG-2026-0001' }).code, 'CG-2026-0001', '单号必须透传用于行尾标记'); assert.notEqual(alertActionFor({ status: 'critical', purchaseRequestCode: 'CG-2026-0001' }).primary, 'purchase', '有单号时绝不出现「生成采购申请」,否则就是重复下单入口'); assert.equal(alertActionFor({ status: 'critical', purchaseRequestCode: 'CG-2026-0001' }).document, false, '主按钮已是「打开采购需求」时不得再渲染一次'); assert.equal(alertActionFor({ status: 'critical' }).primary, 'purchase', '缺料行无单号时给「生成采购申请」'); assert.equal(alertActionFor({ status: 'warning' }).primary, 'purchase', '偏低行无单号时同样给「生成采购申请」'); assert.equal(alertActionFor({ status: 'normal' }).primary, '', '正常行不给任何动作,绝不凭空造一个点了就失败的按钮'); assert.equal(alertActionFor({ status: 'excess', purchaseRequestCode: 'CG-2' }).document, true, '超储行若已有申请单号,额外给「打开采购需求」'); assert.equal(alertActionFor({}).primary, '', '状态缺失时按兜底处理,不给动作'); console.log('F1-(2) alertActionOf 五分支通过:unknown→核对阈值(不给补货)、excess→发起调拨、有单号→打开采购需求(绝不出补货)、critical/warning→生成采购申请、normal→无动作'); // 一行一个物料后,未选仓库时后端给 warehouseId/warehouseName=NULL:alerts 视图必须写「全部授权仓库」, // 其它视图(bpm/io/todo/age/dead/turnover/qc)的空仓库仍走既有「—」,渲染一字不变。 assert.equal(detailLogged.methods.cell.call({ view: 'alerts' }, { warehouseName: null }, 'warehouseName'), '全部授权仓库', 'alerts 视图未选仓库(warehouseName 为 NULL)时仓库列必须显示「全部授权仓库」'); assert.equal(detailLogged.methods.cell.call({ view: 'alerts' }, { warehouseName: '' }, 'warehouseName'), '全部授权仓库', 'warehouseName 为空串同样按未选仓库处理'); assert.equal(detailLogged.methods.cell.call({ view: 'alerts' }, { warehouseName: '主仓' }, 'warehouseName'), '主仓', '选了仓库时必须显示该仓名,不得被「全部授权仓库」覆盖'); for (const otherView of ['io', 'todo', 'age', 'dead', 'turnover', 'qc', 'bpm']) { assert.equal(detailLogged.methods.cell.call({ view: otherView }, { warehouseName: null }, 'warehouseName'), '—', otherView + ' 视图的仓库列必须保持原有「—」占位,预警口径不得外溢'); } // 预警类型下拉:顺序与后端 ORDER BY 一致(超储→未配置→待核实),且筛选值就是后端 level 取值。 assert.match(detailSource, /