| 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598 |
- // 只读断言:直接加载现有组件方法,禁止发出真实业务请求。
- 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'"[^>]*><input/, 'qc 的统计区间不得渲染成可编辑输入框');
- console.log('质检明细页时间窗守卫通过:qc 不渲染可编辑日期。');
- console.log('首页四卡与质检明细断言通过。');
- // ===== D1「出入库动态图」:近 30 天滚动窗口、缺数据 null、无作业日、连续同号风险、点击下钻 =====
- assert.equal(utilConst('TREND_WINDOW_DAYS'), 30, 'D1 窗口固定为近 30 天滚动(含今日)');
- assert.equal(utilConst('TREND_RISK_MIN_DAYS'), 2, '连续同号 >=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<secure 但后端给 normal 时也照 normal 展示。
- const alertTampered = buildAlertRows([{ id: 'x', name: '物料X', status: 'normal', statusLabel: '正常', availableQuantity: 1, secureInventory: 100, gapQuantity: 0, gapAmount: 0 }], ALERT_TOP_LIMIT);
- assert.equal(alertTampered.rows[0].status, 'normal', '前端不得按 available/secure 复算状态(复算会在改系数后与后端静默分叉)');
- assert.equal(alertTampered.rows[0].statusLabel, '正常', '前端不得改写后端下发的状态标签');
- // 汇总条全 null:一律「—」,且不得用当前可见行数冒充 alertCount(前端自己加总与清单页条数立刻分叉)。
- const alertEmptySummary = buildAlertSummary({ alerts: [{ id: '1' }, { id: '2' }, { id: '3' }], alertCount: null, alertUnknownCount: null, alertGapAmount: null, alertWorkOrderCount: null });
- assert.equal(alertEmptySummary.countText, '—', 'alertCount 缺失必须显示「—」');
- assert.equal(alertEmptySummary.unknownText, '—', 'alertUnknownCount 缺失必须显示「—」');
- assert.equal(alertEmptySummary.gapAmountText, '—', 'alertGapAmount 缺失必须显示「—」');
- assert.equal(alertEmptySummary.workOrderText, '—', 'alertWorkOrderCount 缺失必须显示「—」,绝不按 0');
- assert.notEqual(alertEmptySummary.countText, '3', '汇总条不得用可见行数冒充 alertCount');
- const alertFilledSummary = buildAlertSummary({ alertCount: 12, alertUnknownCount: 2, alertGapAmount: 1234.5, alertWorkOrderCount: 3 });
- assert.equal(alertFilledSummary.countText, '12', 'alertCount 有值时原样展示(缺料+偏低+超储,待核实不计入)');
- assert.equal(alertFilledSummary.gapAmountText, '1,234.50 元', '缺口金额合计固定两位小数 + 千分位');
- assert.equal(alertFilledSummary.workOrderText, '3', '影响生产工单数由后端给出,前端只展示');
- // 未配置计数(alertUnconfiguredCount):缺失/为空按 0 处理且整项不渲染,绝不打「未配置 — 项」这种假值。
- assert.equal(alertEmptySummary.unconfiguredCount, 0, 'alertUnconfiguredCount 缺失时必须按 0 处理(模板据此整项不渲染)');
- assert.equal(alertEmptySummary.unconfiguredText, '0', '未配置计数缺失时文本给 0,不得留「—」冒充缺失');
- assert.notEqual(alertEmptySummary.unconfiguredText, '—', '未配置计数不得显示占位符:那是「后端没给」,不是「没有未配置项」');
- assert.equal(buildAlertSummary({ alertUnconfiguredCount: 4 }).unconfiguredCount, 4, '未配置计数必须直读后端 alertUnconfiguredCount');
- assert.equal(buildAlertSummary({ alerts: [{ id: '1', status: 'unconfigured' }], alertUnconfiguredCount: null }).unconfiguredCount, 0, '未配置计数不得用可见行数冒充后端汇总');
- console.log('F1-(1) 纯函数断言通过:statusLabel/color 优先级、normal 不造色、缺价「金额待补价」而 0→0.00、TOP5 截断与 overflow、状态不复算、汇总条全 null→「—」且不自算合计');
- // —— (2) detail.vue 的 alertActionOf 五分支(经 computed rows 预计算后读取)——
- const alertActionFor = (row) => 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, /<option value="excess">超储<\/option><option value="unconfigured">未配置<\/option><option value="unknown">/, '预警类型下拉必须按 超储→未配置→待核实 排列');
- assert.match(detailSource, /<option value="unconfigured">未配置<\/option>/, '预警类型下拉必须提供 level=unconfigured「未配置」选项');
- console.log('F1-(2b) 清单页守卫通过:未选仓库显示「全部授权仓库」(仅 alerts)、其它视图空仓库仍为「—」、下拉新增 level=unconfigured 且排在超储之后待核实之前');
- // —— (3) 首页卡片模板守卫:三色点、状态标签、影响工单、已生成申请、金额待补价 ——
- assert.match(overviewSource, /:style="\{ background: item\.color, color: item\.color \}"/, '三色状态点必须取 item.color(后端 color,缺失时 alertColorOf 按 status 兜底)');
- assert.match(overviewSource, /class="alert-state" :style="\{ color: item\.color \}"[\s\S]{0,40}\{\{ item\.statusLabel \}\}/, '状态中文标签必须与状态点同排且用后端 statusLabel');
- assert.match(overviewSource, /影响生产工单/, '汇总条必须出现「影响生产工单」');
- assert.match(overviewSource, /已生成申请/, '卡片必须给出「已生成申请」标记,避免同一行被重复下单');
- assert.match(overviewSource, /金额待补价/, '卡片必须写明缺价行显示「金额待补价」,不得渲染成 0');
- assert.match(overviewSource, /item\.gapText/, '行内必须展示缺口量/缺口金额文案');
- assert.match(overviewSource, /alertSummary\.workOrderText/, '汇总条工单数必须消费后端 workOrderText(null 时是「—」)');
- assert.match(overviewSource, /level: 'critical'/, '「影响生产工单」下钻必须按 level=critical,与工单数同源');
- // 未配置 N 项:卡片必须渲染,且数字只读后端 summary.alertUnconfiguredCount(前端自己按行加总会与「全部 N 项」分叉)。
- assert.match(overviewSource, /alertSummary\.unconfiguredCount/, 'F1 卡片必须渲染未配置计数(消费 buildAlertSummary 归一后的 unconfiguredCount)');
- assert.match(overviewSource, /alertSummary\.unconfiguredText/, '未配置计数文本必须由汇总层给(缺失时按 0,不打假占位符)');
- assert.match(overviewSource, /summary\.alertUnconfiguredCount/, '未配置计数必须来自后端 summary.alertUnconfiguredCount,前端不得按可见行加总');
- assert.match(overviewSource, /未配置 \{\{ alertSummary\.unconfiguredText \}\} 项/, '卡片文案必须是「未配置 N 项」,且 N 取后端汇总值');
- assert.match(overviewSource, /alert-unconfigured-note/, '未配置说明必须独立成项,不能混进待核实那条说明');
- assert.match(detailSource, /含待检、未放行批次/, '清单页口径条必须写明可用量含待检/未放行批次');
- // 渲染层:未配置计数有值才出「未配置 N 项」,缺失时按 0 处理且整项不渲染(模板 v-if unconfiguredCount > 0)。
- const cardAlertSummary = (summary) => componentState(overviewLogged, { summary }).alertSummary;
- const cardNoUnconfigured = cardAlertSummary({ alertCount: 5, alertUnknownCount: 1 });
- assert.equal(cardNoUnconfigured.unconfiguredCount, 0, 'summary 缺 alertUnconfiguredCount 时卡片必须按 0 处理');
- assert.equal(cardNoUnconfigured.unconfiguredTitle, '', '计数为 0 时不生成提示文案,模板据此整项不渲染,不打假值');
- const cardUnconfigured = cardAlertSummary({ alertCount: 5, alertUnconfiguredCount: 3 });
- assert.equal(cardUnconfigured.unconfiguredCount, 3, '未配置计数必须原样取后端 alertUnconfiguredCount');
- assert.equal(cardUnconfigured.unconfiguredText, '3', '「未配置 N 项」的 N 必须来自后端汇总,不是可见行数');
- assert.equal(cardUnconfigured.countText, '5', '新增未配置项不得改变 alertCount(缺料+偏低+超储)的展示');
- assert.match(cardUnconfigured.unconfiguredTitle, /is_warn=1/, '未配置提示必须说明「三级阈值来源都取不到」,不能只说没配阈值');
- assert.match(cardUnconfigured.unconfiguredTitle, /不计入预警条数/, '未配置提示必须说明不计入预警条数');
- console.log('F1-(3) 卡片模板守卫通过:三色 fallback、状态标签同排、影响生产工单、已生成申请、金额待补价、工单下钻 level=critical、未配置 N 项读 alertUnconfiguredCount');
- // —— (4) screens.alerts 口径文案守卫:新口径关键词必须在,旧口径不得复现 ——
- const alertDefinition = screenDefs.alerts.definition;
- assert.match(alertDefinition, /含待检/, '预警口径条必须写明可用量含待检批次');
- assert.match(alertDefinition, /偏低系数/, '预警口径条必须写明 K1 偏低系数');
- assert.match(alertDefinition, /超储兜底/, '预警口径条必须写明 K2 超储兜底系数');
- assert.doesNotMatch(alertDefinition, /排除未放行/, '「排除未放行」是 batchRows 的口径,不得再出现在预警口径条里');
- assert.match(alertDefinition, /最低库存仅作展示列、不参与触发判定/, '口径条必须写明最低库存不参与触发判定');
- assert.match(alertDefinition, /最大库存(允许为空/, '口径条必须写明最大库存可为空');
- assert.match(alertDefinition, /缺料[\s\S]{0,40}偏低[\s\S]{0,40}超储/, '口径条必须写明短路顺序 缺料→偏低→超储');
- assert.match(alertDefinition, /待核实单列且不计入/, '口径条必须写明待核实单列且不计入预警条数');
- // 新口径:一行一个物料、全部授权仓库合计、阈值来源三级优先级、未配置单列不计入。
- assert.match(alertDefinition, /一行一个物料/, '口径条必须写明「一行一个物料」(清单按物料出行,不是一条阈值配置一行)');
- // 2026-11-13 单仓视图收窄:选定仓库后只列该仓有库存或该仓有 is_warn=1 阈值配置的物料(只查对应仓库的信息)。
- assert.match(alertDefinition, /选定仓库后只列「该仓有库存」或「该仓有 is_warn=1 阈值配置」的物料/, '口径条必须写明选定仓库后的行集收窄规则(该仓有库存 或 该仓有 is_warn=1 阈值配置)');
- assert.match(alertDefinition, /未选仓库=物料主数据全量/, '口径条必须写明未选仓库时仍是物料主数据全量(不能把收窄规则说成全量)');
- assert.match(alertDefinition, /全部授权仓库合计/, '口径条必须写明可用量按全部授权仓库合计(含待检/未放行)');
- assert.match(alertDefinition, /选择仓库时按该仓/, '口径条必须写明选了仓库时按该仓聚合');
- assert.match(alertDefinition, /is_warn=1/, '阈值来源优先级第一级必须是该仓 is_warn=1 配置');
- assert.match(alertDefinition, /物料全局配置/, '阈值来源优先级第二级必须是物料全局配置');
- assert.match(alertDefinition, /唯一仓级配置兜底(仅「全部授权仓库」视图/, '第三级兜底必须限定在全部授权仓库视图(选定单仓后不得借用别的仓库阈值)');
- assert.match(alertDefinition, /选定仓库后不再借用其它仓库的阈值/, '口径条必须写明选定单仓后不借用其它仓库阈值');
- assert.match(alertDefinition, /完全没有阈值配置=「未配置」(不计入预警条数)/, '口径条必须写明完全没有阈值配置=未配置且不计入预警条数');
- assert.match(alertDefinition, /阈值非法或多份冲突=「待核实」/, '口径条必须写明阈值非法/多份冲突=待核实');
- assert.match(alertDefinition, /未配置/, '口径条必须出现「未配置」');
- assert.match(alertDefinition, /缺料\/偏低\/超储判定与缺口金额口径不变/, '口径条必须显式声明缺料/偏低/超储判定与缺口金额口径不变');
- assert.match(screenDefs.alerts.subtitle, /未配置/, '副标题必须把未配置纳入核对范围');
- assert.match(screenDefs.alerts.subtitle, /一行一个物料/, '副标题必须写明一行一个物料的新口径');
- console.log('F1-(4) screens.alerts 文案守卫通过:含待检、偏低系数、超储兜底、最低库存不参与判定、最大库存可空、待核实单列、一行一个物料/全部授权仓库合计/三级阈值优先级/未配置不计入,且不再出现「排除未放行」');
- // —— (5) 后端 SQL 静态守卫(只读文本;后端仓库不在同级目录时 SKIP 而非 fail)——
- const alertMapperPath = path.resolve(root, '..', 'aiot202312/aiot-biz/wms-biz/wms-biz-provider/src/main/resources/mapper/WmsHomeMapper.xml');
- if (!fs.existsSync(alertMapperPath)) {
- console.log('SKIP F1-(5) 后端 SQL 静态守卫:未找到 ' + alertMapperPath + '(后端仓库不在当前工作区同级目录,跳过不 fail)');
- } else {
- const alertMapperXml = fs.readFileSync(alertMapperPath, 'utf8');
- const sqlFragment = (id) => {
- const start = alertMapperXml.indexOf('<sql id="' + id + '">');
- if (start < 0) return null;
- const end = alertMapperXml.indexOf('</sql>', start);
- return end < 0 ? null : alertMapperXml.slice(start, end);
- };
- const alertFragment = sqlFragment('alertRows');
- const batchFragment = sqlFragment('batchRows');
- assert.ok(alertFragment, 'alertRows 片段必须存在(预警列表与首页 TOP5 共用)');
- assert.ok(batchFragment, 'batchRows 片段必须存在');
- // critical 判定行:只能由 secureInventory 判,不得引用 minInventory(最低库存只作展示列)。
- const alertCriticalLines = alertFragment.split('\n').filter((line) => /THEN 'critical'/.test(line));
- assert.equal(alertCriticalLines.length, 1, 'critical 判定行必须唯一(短路判定里出现两处说明有人改坏了 CASE)');
- assert.doesNotMatch(alertCriticalLines[0], /minInventory/, 'critical 判定不得引用 minInventory:最低库存只作展示列、不参与触发');
- assert.match(alertCriticalLines[0], /secureInventory/, 'critical 必须由 secureInventory 判定(可用量<安全库存)');
- // K1/K2 必须由 Mapper 参数下发,不能写死 1.2 / 3——写死就没法按环境调。
- assert.match(alertFragment, /#\{warningRatio\}/, 'warning 判定必须用参数 #{warningRatio}(wms.home.alert.warning-ratio,默认 1.2)');
- assert.match(alertFragment, /#\{excessRatio\}/, '超储兜底必须用参数 #{excessRatio}(wms.home.alert.excess-ratio,默认 3)');
- // 派生层别名写死(后端最终 SQL 是 t→b1→ar 三层):写成 t. 而不是 \w+. ,后端再换别名会立刻红,不被通配悄悄放过。
- // 语义不变:仍锁「超储兜底只在 maxInventory 为空时生效」。
- assert.match(alertFragment, /COALESCE\(t\.maxInventory,t\.secureInventory\*#\{excessRatio\}\)/, '超储兜底只应在 maxInventory 为空时生效');
- // 排序:缺口金额倒序 + 缺价(NULL)排最后 + 状态严重度 + id 稳定收尾。
- assert.match(alertMapperXml, /ORDER BY gapAmount IS NULL,gapAmount DESC/, '预警排序必须 gapAmount IS NULL,gapAmount DESC(缺价行排最后,不依赖 DESC 的隐式 NULL 规则)');
- // 后端最终 SQL 已把未配置排在 excess 之后、normal 之前:锁死新顺序(与前端 ALERT_STATUS_ORDER 逐字一致),
- // 不再允许可选分组——后端若回退到旧排序必须立刻红。
- assert.match(alertMapperXml, /FIELD\(status,'critical','warning','excess','unconfigured','normal','unknown'\)/, '预警次级排序必须按状态严重度 critical→warning→excess→unconfigured→normal→unknown');
- // 护栏①:batchRows 的 availableQuantity 定义不得改(四个既有 KPI 同时消费它)。
- assert.match(batchFragment, /available_count_base-COALESCE\(b\.lock_count_base,0\)/, 'batchRows 的 availableQuantity 必须仍是 available_count_base−锁定量(护栏:改它会静默改掉四个既有消费者的数字)');
- assert.equal((batchFragment.match(/AS availableQuantity/g) || []).length, 1, 'batchRows 只能有一个 availableQuantity 定义');
- // 护栏②:预警可用量必须走独立 av 子查询(Σ在库量−Σ锁定量,含待检),不得复用 batchRows 的 available_count_base 口径。
- assert.match(alertFragment, /SUM\(b\.stock_count_base\)-SUM\(COALESCE\(b\.lock_count_base,0\)\)/, '预警可用量必须是独立 av 子查询的 Σ(stock_count_base)−Σ(lock_count_base)(含待检)');
- assert.doesNotMatch(alertFragment, /available_count_base/, '预警可用量不得复用 batchRows 的 available_count_base(那会排除未放行批次,与阈值判定口径冲突)');
- // 缺口量 / 缺口金额 / 工单数 / 申请单号的 SQL 语义(缺价为 NULL,不兜底成 0)。
- assert.match(alertFragment, /GREATEST\(b1\.secureInventory-b1\.availableQuantity,0\)/, '缺口量必须是 GREATEST(安全库存−可用量,0)');
- assert.match(alertFragment, /ar\.gapQuantity\*ar\.costUnitPrice/, '缺口金额必须是 缺口量×移动加权不含税单价');
- assert.match(alertFragment, /THEN '缺口物料缺少移动加权不含税单价,缺口金额不可折算'/, '缺价时必须给 gapAmountReason,不得用 0 冒充');
- assert.match(alertFragment, /CASE WHEN ar\.status='critical' THEN wo\.workOrderCount END AS workOrderCount/, '行级 workOrderCount 只给 critical 行,非缺料行必须是 NULL 而不是 0');
- assert.match(alertFragment, /command_type/, '申请单号必须关联 t_wms_dashboard_command(command_type=PURCHASE)');
- assert.match(alertFragment, /CAST\(pc\.business_id AS CHAR\) AS purchaseRequestId/, '申请主键必须 CAST AS CHAR,禁止让大整数进 JS 数字');
- // 阈值落库:max_inventory 允许留空 → jdbcType=DECIMAL 无条件写,留空写 NULL。
- assert.match(alertMapperXml, /max_inventory=#\{q\.maxInventory,jdbcType=DECIMAL\}/, '阈值 insert 必须显式 jdbcType=DECIMAL(max_inventory 允许留空写 NULL)');
- assert.match(alertMapperXml, /max_inventory=#\{q\.maxInventory,jdbcType=DECIMAL\},update_user_id/, '阈值 update 必须显式 jdbcType=DECIMAL(留空写 NULL,不能要求必填)');
- // —— 2026-11-13 单仓视图收窄(用户口径「只查询对应仓库的信息」)——
- // ① 行集:选定仓库时只保留「该仓有库存(av.quantity>0)或该仓有 is_warn=1 阈值配置(cfg.warehouseConfigCount>0)」;
- // 判据必须复用 av/cfg 两个已算好的聚合,禁止再写一遍库存子查询(逐行 EXISTS 实测 13s → 0.1s)。
- const warehouseRowSetBlock = /<if test="q\.warehouseId != null">\s*AND \(COALESCE\(av\.quantity,0\)>0 OR COALESCE\(cfg\.warehouseConfigCount,0\)>0\)\s*<\/if>/;
- assert.match(alertFragment, warehouseRowSetBlock, '选定仓库时必须按「该仓有库存 或 该仓有阈值配置」收窄行集,且复用 av/cfg 聚合');
- assert.match(alertFragment, /SUM\(CASE WHEN v\.warehouseId=#\{q\.warehouseId,jdbcType=BIGINT\} THEN 1 ELSE 0 END\) AS whConfigCount/, 'whConfigCount 必须由 pick 聚合按该仓配置计数派生(不要新增子查询)');
- // ② 第三级兜底(别的仓库那条配置)只能在「未选仓库」视图出现:它必须包在 q.warehouseId == null 的 if 里。
- const pickIfStart = alertFragment.indexOf('<if test="q.warehouseId == null">');
- assert.ok(pickIfStart > 0, '第三级兜底必须由 <if test="q.warehouseId == null"> 把关');
- const pickIfEnd = alertFragment.indexOf('</if>', pickIfStart);
- const pickIfBlock = alertFragment.slice(pickIfStart, pickIfEnd);
- assert.match(pickIfBlock, /'fallback'/, "选定单仓后不得再出 'fallback'(借用别的仓库阈值)");
- assert.match(pickIfBlock, /'ambiguous'/, '选定单仓后多份仓级配置也不得判为 ambiguous 而应落 none');
- console.log('F1-(5) 后端 SQL 静态守卫实际执行通过(未 SKIP):critical 只由 secureInventory 判、无 minInventory、K1/K2 走参数、gapAmount DESC 排序、batchRows 护栏、av 子查询 Σ 口径、缺价 NULL、workOrderCount 仅 critical、business_id CAST CHAR、max_inventory jdbcType=DECIMAL');
- }
- // ===== E3「最近作业动态」断言块 =====
- // 口径来源:docs/仓储首页看板口径.md 的 E3 节 + WmsHomeMapper.xml 的 activities 分支。
- // 只读既有实现:装载 dashboard-utils.js 调真实纯函数(一律传固定 now,否则断言会跟着跑脚本的当天时钟漂),
- // 模板/样式只做源码字符串断言。全程不发请求、不写任何文件。
- const {
- formatActivityTime, activityStatusOf, buildActivityFeed, diffActivityIds
- } = utilsLogged;
- // const 常量落在 vm 词法作用域、不会成为上下文属性,必须用 utilConst 取(同 STAGNANT_DEFAULT_DAYS / ALERT_TOP_LIMIT)。
- // 2026-11-10 起卡片改「最多 50 条 + 容器内自动滚动」:5 条填不满一屏,没有可滚内容,
- // 「最近动态」就只剩静态列表。50 与后端 ACTIVITY_FEED_LIMIT、统计接口 STATISTICS_ACTIVITY_MAX_LIMIT 同值。
- assert.equal(utilConst('ACTIVITY_LIMIT'), 50, '最近作业动态最多 50 条(容器内自动滚动,不再固定 5 条)');
- assert.equal(utilConst('ACTIVITY_SCROLL_INTERVAL_MS'), 3000, '自动滚动周期必须 3 秒一行:慢到能读,又不至于半天不动');
- // 超时口径必须与待办条(overdueInbound/overdueOutbound/overdueApproval)同源 24 小时,
- // 否则同一屏上「待入库单超时」与「入库流水超时」会用两个阈值各说一套。
- assert.equal(utilConst('ACTIVITY_OVERDUE_HOURS'), 24, '待* 超时阈值必须与待办条同口径 24 小时');
- // 固定 now=本地时间 2026-10-20 15:30,四段文案与超时判定全部由它推出,脚本哪天跑结果都一样。
- const activityNow = new Date(2026, 9, 20, 15, 30, 0);
- // —— (1) 状态词 → tone 色表:文案与颜色解耦的唯一来源 ——
- const activityStyles = utilConst('ACTIVITY_STATUS_STYLES');
- const activityToneOf = (word) => (activityStyles[word] || {}).tone;
- const activityStyleTones = Object.keys(activityStyles).map((word) => activityToneOf(word));
- const ACTIVITY_TONES = ['done', 'waiting', 'doing', 'danger'];
- // 表里每个词都必须有合法 tone:漏一个会让模板拼出 'feed-status undefined',那一行状态直接无色。
- assert.equal(activityStyleTones.filter((tone) => ACTIVITY_TONES.indexOf(tone) === -1).length, 0, '状态色表里每个状态词都必须映射到 done/waiting/doing/danger 之一(否则模板会拼出无色状态)');
- assert.equal(ACTIVITY_TONES.filter((tone) => activityStyleTones.indexOf(tone) === -1).length, 0, '四种 tone 必须都被至少一个状态词使用,否则说明色表被删词');
- assert.equal(activityToneOf('已完成'), 'done', '已完成=闭环,必须绿色 done');
- assert.equal(activityToneOf('已执行'), 'done', '已执行=闭环(调拨),必须绿色 done');
- assert.equal(activityToneOf('待质检'), 'waiting', '待质检=在等质检处理,必须橙色 waiting');
- assert.equal(activityToneOf('待审批'), 'waiting', '待审批=在等审批,必须橙色 waiting');
- assert.equal(activityToneOf('待执行'), 'waiting', '待执行=还没开始,必须橙色 waiting(超时角标只跟 waiting 走)');
- assert.equal(activityToneOf('进行中'), 'doing', '进行中=正在跑,必须青色 doing');
- assert.equal(activityToneOf('已驳回'), 'danger', '已驳回=出问题,必须红色 danger');
- assert.equal(activityToneOf('异常'), 'danger', '异常=出问题,必须红色 danger');
- // —— (2) formatActivityTime 四段:今日 HH:mm / 昨日 / MM-DD / — ——
- // 今日必须补前导 0(09:05 不能写 9:5):这是「今日 HH:mm」与后端时间串的唯一视觉差别。
- assert.equal(formatActivityTime('2026-10-20 09:05:00', activityNow), '今日 09:05', '今日事件必须显示「今日 HH:mm」,小时与分钟都补前导 0');
- assert.equal(formatActivityTime('2026-10-20 23:59:00', activityNow), '今日 23:59', '当天 23:59 仍算今日,不得提前算成昨日');
- assert.equal(formatActivityTime('2026-10-19 23:59:00', activityNow), '昨日', '昨日事件只显示「昨日」,不显示时刻');
- assert.equal(formatActivityTime('2026-10-18 10:00:00', activityNow), '10-18', '更早事件显示 MM-DD');
- assert.equal(formatActivityTime('2026-09-05 08:00:00', activityNow), '09-05', '更早事件的月/日也要补前导 0(09-05 不能写 9-5)');
- assert.equal(formatActivityTime('', activityNow), '—', '空时间必须给占位符「—」,不能显示成今日');
- assert.equal(formatActivityTime(null, activityNow), '—', 'null 时间必须给占位符「—」');
- assert.equal(formatActivityTime('不是时间', activityNow), '—', '非法时间串必须给占位符,绝不拿「现在」兜底——那会把一条陈年流水顶到列表最前面');
- // —— (3) activityStatusOf:先按 activityType 分流,再谈 status ——
- const activityStatus = (row) => { const status = activityStatusOf(row); return status.text + '/' + status.tone; };
- assert.equal(activityStatus({ activityType: 'inventory', status: 0 }), '待执行/waiting', '盘点 status 0 必须「待执行」橙');
- assert.equal(activityStatus({ activityType: 'inventory', status: 1 }), '进行中/doing', '盘点 status 1 必须「进行中」青');
- assert.equal(activityStatus({ activityType: 'inventory', status: 2 }), '已完成/done', '盘点 status 2 必须「已完成」绿');
- // 本卡最容易被改坏的一条:io 行的 status 恒为 null,而 Number(null) === 0。
- // 一旦把 status 判断提到类型分流之前,审核通过的入库单会整片显示成「待执行」并挂上超时角标(假待办)。
- assert.equal(activityStatus({ activityType: 'io', status: null }), '已完成/done', 'io 的 status 为 null 时必须「已完成」,绝不能因 Number(null)===0 退化成「待执行」');
- assert.equal(activityStatus({ activityType: 'io' }), '已完成/done', 'io 完全没有 status 字段时同样「已完成」');
- assert.equal(activityStatus({ activityType: 'io', status: 0 }), '已完成/done', 'io 即使带着 0 也仍是「已完成」(后端只把审核通过的流水放进 activities)');
- assert.equal(activityStatus({ activityType: 'transfer', status: null }), '已执行/done', '调拨恒为「已执行」,status 为 null 时不得退化成「待执行」');
- assert.equal(activityStatus({ activityType: 'transfer' }), '已执行/done', '调拨缺 status 时同样「已执行」');
- // 未识别一律中性灰:造 done 会被读成业务结论,造 waiting 会凭空生成一个待办并跟着挂超时角标。
- assert.equal(activityStatus({ activityType: '质检单' }), '状态待核实/neutral', '未识别 activityType 必须回落 neutral,不得猜成 done/waiting');
- assert.equal(activityStatus({}), '状态待核实/neutral', '完全没有类型的行必须回落 neutral');
- assert.equal(activityStatus({ activityType: 'inventory', status: 9 }), '状态待核实/neutral', '未识别盘点 status 必须回落 neutral,绝不猜成某个已知状态');
- assert.equal(activityStatus({ activityType: 'inventory', status: null }), '状态待核实/neutral', '盘点缺 status 时回落 neutral,不得默认成「待执行」');
- // —— (4) buildActivityFeed:去重(同单号留最新)→ operateTime 倒序 → 最多 50 条 ——
- // fixture:8 条入参、含 1 条重复(O6 两条),期望 total=8 / deduped=1 / shown=7 / overflow=0(未到上限不丢行)。
- // 重复的两条刻意把「旧的一条排在前面」,用来证明去重认的是 operateTime 而不是先到者。
- const activityFeedRows = [
- { id: 'A1', orderId: 'O1', orderNo: 'RK-001', activityType: 'io', direction: 1, status: null, operateTime: '2026-10-20 14:00:00', itemCount: 3, warehouseName: '一号库' },
- { id: 'A2', orderId: 'O2', orderNo: 'CK-002', activityType: 'io', direction: 2, status: null, operateTime: '2026-10-20 12:00:00', itemCount: 12, warehouseName: '二号库' },
- { id: 'A3', orderId: 'O3', orderNo: 'DB-003', activityType: 'transfer', status: null, operateTime: '2026-10-20 10:00:00', itemCount: 2, warehouseName: '三号库' },
- { id: 'A4', orderId: 'O4', orderNo: 'PD-004', activityType: 'inventory', operateTime: '2026-10-19 18:00:00', itemCount: 1, warehouseName: '四号库', status: 1, description: '执行中' },
- { id: 'A5', orderId: 'O5', orderNo: 'PD-005', activityType: 'inventory', operateTime: '2026-10-19 09:00:00', itemCount: 1, warehouseName: '五号库', status: 0 },
- { id: 'A6', orderId: 'O6', orderNo: 'RK-006', activityType: 'io', direction: 1, status: null, operateTime: '2026-10-18 09:00:00', itemCount: 4, warehouseName: '六号库' },
- { id: 'A7', orderId: 'O6', orderNo: 'RK-006', activityType: 'io', direction: 1, status: null, operateTime: '2026-10-20 08:00:00', itemCount: 6, warehouseName: '六号库' },
- { id: 'A8', orderId: 'O7', orderNo: 'PD-007', activityType: 'inventory', operateTime: '2026-10-17 09:00:00', itemCount: 1, warehouseName: '七号库', status: 2 }
- ];
- const activityFeed = buildActivityFeed(activityFeedRows, activityNow);
- const activityById = (feed, id) => feed.items.filter((item) => item.id === id)[0] || {};
- assert.equal(activityFeed.total, 8, 'total 必须是入参条数 8(含重复),用于核对后端到底回了几行');
- assert.equal(activityFeed.deduped, 1, 'deduped 必须记 1 条被去掉的重复单据');
- assert.equal(activityFeed.items.length, 7, '上限 50 条:fixture 去重后 7 条必须全部保留,不得再截断到 5 条');
- assert.equal(activityFeed.overflow, 0, 'overflow=去重后 7 条 − 展示 7 条 = 0:没超上限就不许丢行');
- assert.equal(activityFeed.items.map((item) => item.id).join('|'), 'A1|A2|A3|A7|A4|A5|A8', '必须按 operateTime 倒序全量返回:A6 是同单号的旧记录(去重后只留较新的 A7),A8 是最早的一条,超过 5 条后也必须保留');
- assert.equal(activityFeed.items.filter((item) => item.orderId === 'O6').length, 1, '同一 orderId 在卡片上只能出现 1 次,否则同一张单会被看两遍');
- // 盘点动作文案:以「盘点」开头 + 带库区 + **绝不出现「项」**。
- // 后端盘点行的 itemCount 是占位常量 1(WmsHomeMapper.xml 盘点分支 CAST 成 1),拼成「盘点 1 项」就是伪造明细数。
- const activityInventory = activityById(activityFeed, 'A4');
- assert.match(activityInventory.actionText, /^盘点/, '盘点行动作文案必须以「盘点」开头(后端 description 里的状态词不得当动作描述)');
- assert.doesNotMatch(activityInventory.actionText, /项/, '盘点行不得渲染 itemCount:后端盘点 itemCount 恒为占位常量 1,「盘点 1 项」是伪造数字');
- assert.match(activityInventory.actionText, /四号库/, '盘点行必须带库区,否则同一时刻的多条盘点无从区分');
- // io/transfer 反而不许丢掉真实明细行数:itemCount 是后端 COUNT(*) 真明细行数,只写「入库」会让人点进去才发现数量。
- assert.match(activityById(activityFeed, 'A1').actionText, /\d+ 项/, '入库行动作文案必须带明细项数(后端 COUNT(*) 真明细行数)');
- assert.match(activityById(activityFeed, 'A1').actionText, /3 项/, '入库行必须显示后端下发的 3 项,不能拿别处的常量顶替');
- assert.match(activityById(activityFeed, 'A1').actionText, /一号库/, '入库行必须带库区');
- assert.match(activityById(activityFeed, 'A3').actionText, /2 项/, '调拨行必须显示后端下发的 2 项');
- assert.match(activityById(activityFeed, 'A3').actionText, /三号库/, '调拨行必须带库区');
- // 下钻参数留在原始字段上:$emit('business','io',item) 依赖 activityType/orderId/orderNo/direction/warehouseId,
- // 展示字段一律用 timeText/actionText/statusText/tone 这类新名字,任何一个同名覆盖都等于悄悄丢掉下钻参数。
- const activityInbound = activityById(activityFeed, 'A1');
- assert.equal(activityInbound.id, 'A1', '原始 id 必须保留(v-for :key 与高亮 indexOf 都用它)');
- assert.equal(activityInbound.orderId, 'O1', '原始 orderId 必须保留(去重键与下钻都靠它)');
- assert.equal(activityInbound.orderNo, 'RK-001', '原始 orderNo 必须保留(单号段直接渲染它)');
- assert.equal(activityInbound.activityType, 'io', '原始 activityType 必须保留,否则下钻落不到 V4 的出入库页签');
- assert.equal(activityInbound.direction, 1, '原始 direction 必须保留,否则入库/出库方向在下钻时丢失');
- assert.equal(activityInbound.operateTime, '2026-10-20 14:00:00', '原始 operateTime 必须保留,不能被 timeText 覆盖');
- assert.equal(activityInbound.status, null, '原始 status 不得被状态文案覆盖(io 行恒为 null)');
- assert.equal(activityInbound.timeText, '今日 14:00', '展示字段 timeText 必须由 formatActivityTime 给出');
- assert.equal(activityInbound.statusText, '已完成', '展示字段 statusText 用新名字,不占用 status');
- assert.equal(activityInbound.tone, 'done', '展示字段 tone 必须落在 done/waiting/doing/danger/neutral 之内');
- // 空态:null/非数组入参必须安全返回空列表(后端未下发 activities、或 summary 还没到),绝不能抛错把整屏打黑。
- for (const badFeed of [null, undefined, [], 'x', {}, 0]) {
- const emptyFeed = buildActivityFeed(badFeed, activityNow);
- assert.equal(emptyFeed.items.length, 0, '空/非数组入参必须返回空列表(入参 ' + String(badFeed) + ')');
- assert.equal(emptyFeed.total, 0, '空/非数组入参的 total 必须是 0(入参 ' + String(badFeed) + ')');
- }
- // —— (5) 超时角标:只有橙色「待*」且事件时间早于 now−24h 才标 ——
- // 给 done/doing 的行套「超时」没有业务含义,只会让用户以为还有活没干;重复求值也不许漂移(30 秒轮询会反复求值)。
- const activityOverdueOf = (row) => buildActivityFeed([row], activityNow).items[0].overdue;
- assert.equal(activityOverdueOf({ id: 'w1', orderId: 'w1', activityType: 'inventory', status: 0, operateTime: '2026-10-18 09:00:00' }), true, '待执行超过 24 小时(54.5h)必须标超时');
- assert.equal(activityOverdueOf({ id: 'w2', orderId: 'w2', activityType: 'inventory', status: 0, operateTime: '2026-10-19 20:00:00' }), false, '24 小时内的待执行不得标超时(19.5h)');
- assert.equal(activityOverdueOf({ id: 'w3', orderId: 'w3', activityType: 'inventory', status: 0, operateTime: '2026-10-19 14:00:00' }), true, '刚过 24 小时(25.5h)必须标超时');
- assert.equal(activityOverdueOf({ id: 'd1', orderId: 'd1', activityType: 'io', direction: 1, operateTime: '2026-09-01 09:00:00' }), false, '已完成行再老也不标超时(绿行没有超时语义)');
- assert.equal(activityOverdueOf({ id: 'd2', orderId: 'd2', activityType: 'transfer', operateTime: '2026-09-01 09:00:00' }), false, '调拨(已执行)行再老也不标超时');
- assert.equal(activityOverdueOf({ id: 'p1', orderId: 'p1', activityType: 'inventory', status: 1, operateTime: '2026-09-01 09:00:00' }), false, '进行中行再老也不标超时(doing 只表达正在跑)');
- const activityFeedAgain = buildActivityFeed(activityFeedRows, activityNow);
- assert.equal(activityFeedAgain.items.map((item) => item.overdue).join('|'), activityFeed.items.map((item) => item.overdue).join('|'), '重复求值的 overdue 必须完全一致(幂等,轮询不得让角标闪来闪去)');
- assert.equal(activityFeedAgain.items.map((item) => item.tone).join('|'), activityFeed.items.map((item) => item.tone).join('|'), '重复求值的 tone 必须完全一致');
- // —— (5b) 自动滚动纯函数:不超出不滚、一次一行、先到底再回顶 ——
- // 滚动位置只由这两个纯函数算,组件只负责把结果写进容器;边界若写在组件里就没法在这里验。
- const { isActivityFeedOverflow, nextActivityScrollTop } = utilsLogged;
- assert.equal(isActivityFeedOverflow(300, 264), true, '内容高于可视区必须判为可滚动');
- assert.equal(isActivityFeedOverflow(264, 264), false, '正好一屏不许滚(否则定时器空转、容器自己抖)');
- assert.equal(isActivityFeedOverflow(265, 264), false, '1px 容差内的亚像素差不算可滚动');
- assert.equal(isActivityFeedOverflow(NaN, 264), false, '测量值非法(容器还没渲染)时不得起滚');
- assert.equal(isActivityFeedOverflow(undefined, 264), false, '测量值缺失时同样不得起滚');
- assert.equal(nextActivityScrollTop(0, 34, 100), 34, '第一拍必须正好上移一行');
- assert.equal(nextActivityScrollTop(34, 34, 100), 68, '之后一拍一行,节奏与行高一致');
- assert.equal(nextActivityScrollTop(68, 34, 100), 100, '越过末尾先停在底部:直接归零会把最后一行吞掉');
- assert.equal(nextActivityScrollTop(100, 34, 100), 0, '已在底部时下一拍回到第一行,形成循环');
- assert.equal(nextActivityScrollTop(0, 0, 100), 0, '行高取不到时必须停在 0,不许乱跳');
- assert.equal(nextActivityScrollTop(0, 34, 0), 0, '不超出可视区时永远返回 0');
- assert.equal(nextActivityScrollTop(-20, 34, 100), 34, '负数 scrollTop 按 0 归一,不得滚到负坐标');
- assert.equal(nextActivityScrollTop(0, 34, NaN), 0, 'maxScroll 非法时不得算出位置');
- // —— (6) diffActivityIds:首屏不整屏高亮、只标新增、同批二次为空 ——
- // prev 为空=首次加载:返回空数组,否则首屏 5 行全部高亮,等于什么都没强调,只是让卡片闪一下。
- assert.equal(diffActivityIds([], [{ id: 'n1', orderId: 'N1' }]).length, 0, '首次加载(prev 为空)必须返回空数组,首屏不得整屏高亮');
- assert.equal(diffActivityIds(null, [{ id: 'n1', orderId: 'N1' }]).length, 0, 'prev 缺失时同样不得高亮');
- const activityPrevItems = [{ id: 'x', orderId: 'X' }, { id: 'y', orderId: 'Y' }];
- const activityNextItems = [{ id: 'y', orderId: 'Y' }, { id: 'z', orderId: 'Z' }];
- assert.equal(diffActivityIds(activityPrevItems, activityNextItems).join('|'), 'z', '只返回 next 里新增的 id,且顺序与 next 一致');
- // 同一批数据二次求值必须返回空数组:activities 是计算属性,每次求值都是新数组,
- // 按引用比较会让 30 秒轮询把同一批行全部判成「新增」,整屏反复闪。
- assert.equal(diffActivityIds(activityNextItems, activityNextItems).join('|'), '', '同一批数据二次调用必须返回空数组(轮询不得让整屏重新高亮)');
- assert.equal(diffActivityIds([{ id: 'old-id', orderId: 'Y' }], [{ id: 'new-id', orderId: 'Y' }]).length, 0, '同一单据换了 id 也不算新增:比较键必须与去重键同源(orderId 优先)');
- // —— (7) 模板四段结构 + 空态 + 「全部动态 ›」入口(源码字符串断言,防止语义被搬回模板)——
- const activitySfc = compiler.parseComponent(overviewSource);
- const activityTpl = activitySfc.template.content;
- assert.match(activityTpl, /class="tm"\s*:title="item\.timeTitle"/, '第一段必须是时间(.tm 渲染 timeText,title 给完整时刻)');
- assert.match(activityTpl, /class="feed-doc"/, '第二段必须是单据类型 + 单号(.feed-doc)');
- assert.match(activityTpl, /class="feed-desc"\s*:title="item\.actionText"/, '第三段必须是动作描述(.feed-desc 渲染 actionText)');
- // 状态色只认 item.tone:允许拼接写法变化('feed-status ' + item.tone 或数组写法),但必须能读到 item.tone,
- // 且模板里绝不能出现写死的 feed-status done/waiting/... —— 写死就等于在模板里又判了一遍业务状态。
- assert.match(activityTpl, /:class="[^"]*feed-status[^"]*item\.tone[^"]*"/, '第四段状态色必须由 item.tone 拼成 feed-status 类(模板里不得再判业务状态)');
- assert.doesNotMatch(activityTpl, /feed-status\s+(?:done|waiting|doing|danger|neutral)\b/, '模板不得写死 feed-status 的具体 tone 类,颜色只能由 item.tone 决定');
- // 单号段必须自己可点,且 @click.prevent.stop:少了 prevent 页面会跳走,少了 stop 会冒泡到整行触发两次下钻。
- assert.match(activityTpl, /class="feed-no"[\s\S]{0,260}@click\.prevent\.stop="openActivity\(item\)"/, '单号必须可点击且带 @click.prevent.stop(防跳转 + 防冒泡双触发下钻)');
- assert.match(activityTpl, /v-if="item\.overdue"\s+class="badge-overdue">超时</, '超时角标必须只在 item.overdue 时渲染「超时」文案');
- // 空态必须有一句固定文案:后端不给 activityReason 时页面不能变成一块空白(那会被当成卡片坏了)。
- // 模板里不止一处 .empty-panel(库龄卡也有一个),所以先从活动卡那句固定文案反查它自己的容器,
- // 直接抓第一个 .empty-panel 会抓到别的卡片、让这条断言永远通过(或永远指向错元素)。
- const activityEmptyIndex = activityTpl.indexOf('今日暂无作业动态');
- assert.ok(activityEmptyIndex > 0, '空态必须有固定文案「今日暂无作业动态」');
- const activityEmptyOpen = activityTpl.lastIndexOf('<div', activityEmptyIndex);
- const activityEmptyTag = activityTpl.slice(activityEmptyOpen, activityTpl.indexOf('>', activityEmptyOpen) + 1);
- assert.match(activityEmptyTag, /class="empty-panel"/, '固定文案必须落在 .empty-panel 空态容器里,不能挂到别的卡片上');
- const activityEmptyHead = activityTpl.slice(activityTpl.indexOf('>', activityEmptyOpen) + 1, activityEmptyIndex + 80);
- assert.match(activityEmptyHead, /^今日暂无作业动态/, '空态第一句必须是固定文案,不能只渲染后端原因');
- assert.match(activityEmptyHead, /v-if="activityReason"/, '后端原因只能作为可选后缀拼在固定文案之后');
- assert.doesNotMatch(activityTpl, /class="empty-panel"[^>]*>\s*<span v-if="activityReason"/, '空态不得只剩 activityReason:后端不给原因时会渲染成空白');
- // V4 入口不许改:「全部动态 ›」仍是 open('io'),改成别的目标会把用户带到别的单据类型列表。
- const activityAllLink = (activityTpl.match(/<a\b[^>]*>全部动态 ›<\/a>/) || [])[0] || '';
- assert.ok(activityAllLink, '「全部动态 ›」入口必须存在(V4 出入库动态的唯一入口)');
- assert.match(activityAllLink, /\$emit\('open', 'io'\)/, '「全部动态 ›」必须仍发 open(\'io\') 落到 V4,不得改成别的目标');
- // —— (8) 高亮:3 秒渐隐定时器 + beforeDestroy 清理;轮询不得动滚动 ——
- const activityScript = activitySfc.script.content;
- assert.match(activityScript, /setTimeout\(\(\) => \{[\s\S]{0,200}?\}, 3000\)/, '新增事件高亮必须是 3000ms 定时器(与 scss 的 3s 渐隐动画同长)');
- assert.match(activityScript, /beforeDestroy\(\)\s*\{[\s\S]{0,260}?clearTimeout\(this\.highlightTimer\)/, 'beforeDestroy 必须清理高亮定时器(否则 3 秒后往已销毁实例写响应式数据)');
- // 滚动守卫前先剥注释:实现里为了说明「只许滚卡片自己」本身就写了这些词,
- // 拿原文匹配会把这条说明当成违规;剥掉注释后剩下的才是真正的代码,守卫挡的就是它。
- const stripCodeComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/[^\n]*/g, '$1');
- const activityOverviewCode = stripCodeComments(overviewSource);
- const activityThemeCode = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard-theme.scss'), 'utf8'));
- // 防呆:剥注释后仍必须读到真实模板与样式,否则下面的「不出现」断言会空转(剥太狠等于什么都没查)。
- assert.match(activityOverviewCode, /class="feed-item"/, '剥注释后仍必须能读到 feed-item 模板(否则滚动守卫空转)');
- assert.match(activityThemeCode, /\.feed-status\.done\s*\{/, '剥注释后仍必须能读到 .feed-status.done 规则(否则滚动守卫空转)');
- // 2026-11-10 起 E3 允许「卡片内自动滚动」,但边界写死:只许动本容器的 scrollTop/scrollTo,
- // 禁止 scrollIntoView / scrollBy / window 与 document 级滚动(会连带把整页顶走);样式表里一个滚动 API 都不许有。
- assert.match(activityOverviewCode, /ref="feedEl"/, '滚动容器必须挂 ref="feedEl":没有句柄就没法只滚这一块');
- assert.match(activityOverviewCode, /@mouseenter="pauseActivityScroll"/, '悬停必须暂停自动滚动,否则行在移动中来不及看清、也点不准单号');
- assert.match(activityOverviewCode, /@focusin="pauseActivityScroll"/, '键盘聚焦必须暂停自动滚动(焦点在行上时内容不能自己走)');
- assert.match(activityOverviewCode, /setInterval\(this\.stepActivityScroll, ACTIVITY_SCROLL_INTERVAL_MS\)/, '滚动必须由 ACTIVITY_SCROLL_INTERVAL_MS 驱动的 setInterval 推进,周期不许在组件里再写一个数');
- assert.match(activityOverviewCode, /nextActivityScrollTop\(/, '滚动位置必须走 nextActivityScrollTop 的纯函数边界,不许在组件里另写一套');
- assert.match(activityScript, /activities\(nextItems, prevItems\)[\s\S]{0,300}?restartActivityScroll/, '数据变化后必须重算滚动(条数变化可能让「可滚」变成「不可滚」)');
- assert.doesNotMatch(activityOverviewCode, /scrollIntoView/, 'HomeOverview.vue 不得 scrollIntoView:会把整个页面一起滚走');
- assert.doesNotMatch(activityOverviewCode, /scrollBy\(/, 'HomeOverview.vue 不得 scrollBy:增量滚动会和 nextActivityScrollTop 的边界判断打架');
- // 页面级滚动一律禁止(document.documentElement 本身在 toggleFullscreen 里是合法的全屏目标,只禁它的滚动用法)。
- assert.doesNotMatch(activityOverviewCode, /window\.scroll(To|By)?\(|document\.scrollingElement|document\.documentElement\.scroll/, 'HomeOverview.vue 不得滚动页面:只许滚卡片自己的容器');
- assert.doesNotMatch(activityThemeCode, /scrollIntoView|scrollTop|scrollTo|scrollBy|scrollLeft/, 'dashboard-theme.scss 不得出现任何滚动 API(样式只负责给滚动条配色)');
- // —— (9) 样式契约:五条 tone 规则 + is-new 渐隐关键帧 ——
- for (const activityTone of ['done', 'waiting', 'doing', 'danger', 'neutral']) {
- assert.match(activityThemeCode, new RegExp('\\.feed-status\\.' + activityTone + '\\s*\\{'), 'dashboard-theme.scss 必须有 .feed-status.' + activityTone + ' 规则:缺一条该状态就无色(neutral 灰是「前端不认识这个状态」的唯一视觉语言)');
- }
- assert.match(activityThemeCode, /\.feed-item\.is-new\s*\{[\s\S]{0,80}?animation:\s*feed-new-fade\s+3s/, '新增行必须有 is-new 的 3s 渐隐动画,时长与 JS 的 3000ms 定时器一致');
- assert.match(activityThemeCode, /@keyframes\s+feed-new-fade\s*\{[\s\S]{0,400}?\}/, 'is-new 的 @keyframes feed-new-fade 必须存在(否则 animation 引用不存在的动画,高亮静默失效)');
- console.log('E3 最近作业动态断言通过:ACTIVITY_LIMIT=50 与待办条同口径 24h 超时、状态色表四 tone 全覆盖(已完成/已执行=done、待*=waiting、进行中=doing、已驳回/异常=danger)、formatActivityTime 四段(今日补前导 0 / 昨日 / MM-DD / 空与非法→「—」)、activityStatusOf 先按类型分流(io status=null 仍是「已完成」,不落 Number(null)===0 陷阱;未识别类型与未识别盘点 status 回落 neutral)、buildActivityFeed 同单号留 operateTime 最新且倒序最多 50 条(total 8/deduped 1/shown 7/overflow 0)、盘点行不带占位 itemCount(无「项」)而 io/transfer 必须带「N 项」、原始 id/orderId/orderNo/activityType/direction/status 全保留、超时只标 waiting 且早于 now−24h(done/doing 再老也不标)并幂等、diffActivityIds 首屏不高亮/只返回新增/同批二次为空、模板四段结构与单号 prevent.stop、超时角标、空态固定文案、「全部动态 ›」仍走 open(io)、3000ms 高亮定时器与 beforeDestroy 清理、ACTIVITY_LIMIT=50 与 ACTIVITY_SCROLL_INTERVAL_MS=3000、滚动纯函数(不足一屏不滚/一次一行/到底先停底部再回顶/非法测量值归零)、组件只滚本容器且悬停与聚焦暂停、轮询只重算不复位、scss 仍无任何滚动 API、scss 五条 tone 规则与 feed-new-fade 关键帧。');
- (async () => {
- const state = { receiving: false, preparedReceipts: [{ requestKey: 'a' }, { requestKey: 'b' }], receiveQueue: [], filters: {}, $confirm: async () => {}, route() {}, $refs: { actions: { showResults() {} } }, refresh() {}, $message: { error(message) { throw new Error(message); } } };
- await Promise.all([page.methods.submitReceipts.call(state), page.methods.submitReceipts.call(state)]);
- assert.equal(calls, 1, '重复点击只能发出一次批量请求');
- assert.equal(state.preparedReceipts.length, 1);
- assert.equal(state.preparedReceipts[0].requestKey, 'b', '失败申请重试保留原幂等键');
- assert.equal(state.receiving, false);
- console.log('仓储看板业务断言通过:月份、空值、大整数身份、授权入口、待办范围、分组下钻、收货去重与失败重试、周转/呆滞后端分级映射、呆滞分子分母不可颠倒(3÷70=4.29%)、pp 环比缺失回归、口径条阈值占位符与 180 回落、stagnantDays 命名守卫。');
- })().catch(error => { console.error(error); process.exitCode = 1; });
- // —— G1 深色主题作用域:看板内与弹层分别着色,离开看板移除 body 标记 ——
- const dashboardElementCode = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard-element.scss'), 'utf8'));
- const dashboardVueCode = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard.vue'), 'utf8'));
- const routerCode = stripCodeComments(fs.readFileSync(path.join(root, 'src/router/index.js'), 'utf8'));
- assert.doesNotMatch(dashboardElementCode, /body\.wms-dashboard-theme/, '不得恢复影响业务页背景的旧全局主题');
- assert.match(dashboardElementCode, /body\.wms-dashboard-open\s*\{/, '挂到 body 的弹层需要看板激活期标记');
- assert.match(dashboardElementCode, /\.wms-home\s*(,|\{)/, 'dashboard-element.scss 必须保留 .wms-home 作用域,否则看板自身的深色样式全部失效');
- assert.match(dashboardElementCode, /\.wms-dashboard-dialog/, '看板专用弹层 .wms-dashboard-dialog 必须保留:append-to-body 的弹层只能靠它着色');
- assert.match(dashboardElementCode, /\.wms-dashboard-popper/, '看板专用下拉面板 .wms-dashboard-popper 必须保留:popper 被挂到 body,靠 .wms-home 覆盖不到');
- assert.match(dashboardVueCode, /document\.body\.classList\.add\('wms-dashboard-open'\)/, '进入看板时须开启弹层着色');
- assert.match(dashboardVueCode, /document\.body\.classList\.remove\('wms-dashboard-open'\)/, '失活或销毁须移除弹层标记');
- assert.doesNotMatch(routerCode, /document\.body\.classList\.(toggle|add|remove)/, 'router 不得按 to.query.dashboard 切换 body 主题 class:dashboard=1 会随首页下钻带到业务页');
- const navigateSource = (dashboardVueCode.match(/navigate\(path, query = \{\}\)[^\n]*/) || [''])[0];
- assert.ok(navigateSource, 'dashboard.vue 必须保留下钻方法 navigate');
- assert.doesNotMatch(navigateSource, /dashboard: *'1'/, 'navigate 不得把 dashboard=1 带进业务页 URL:系统原有入口不携带该参数');
- assert.match(navigateSource, /NavigationDuplicated/, 'navigate 必须吞掉 NavigationDuplicated:重复点同一行不该弹错误提示');
- console.log('G1 深色主题作用域断言通过:看板内样式与弹层标记分离,失活或销毁清理 body 标记,router 不接管主题。');
- // —— H1 首页筛选快照与切仓清理(单位维度已随后端契约整体删除) ——
- const warehouseState = { warehouseId: 'A', summary: { inventoryBatchCount: 99 }, updatedAt: '12:00', options: { warehouses: ['A'] }, optionsLoaded: true,
- $route: { query: { dashboardView: 'home', warehouseId: 'B', unit: 'kg' } } };
- page.methods.readRoute.call(warehouseState);
- assert.equal(warehouseState.warehouseId, 'B');
- assert.equal(warehouseState.unit, undefined, '首页不再维护单位状态:后端已删除 unit 参数');
- assert.equal(warehouseState.filters.unit, undefined, 'URL 里的历史 unit 参数不再进入请求参数(filterKeys 已移除 unit)');
- assert.equal(warehouseState.filters.categoryId, '', '缺省分类用空串匹配全部选项');
- assert.deepEqual(Object.keys(warehouseState.homeFilters), ['warehouseId'], '首页筛选快照只剩仓库');
- assert.equal(warehouseState.summary.inventoryBatchCount, undefined, '切仓不能留下前一个仓库的数值');
- assert.equal(warehouseState.optionsLoaded, false, '切仓重新查询筛选项');
- assert.equal(warehouseState.updatedAt, '');
- assert.equal(page.methods.defaultUnit, undefined, '默认单位链路必须整条删除:defaultUnit 不再存在');
- // 切仓后每个指标请求(含 E1 库龄结构、F1 安全库存预警)都必须带上当前仓库:参数只由 parameters() 生成,
- // 它一旦不再透传 warehouseId,后端就只能按全部授权仓库汇总——卡片看起来「不跟随仓库」。
- assert.equal(page.methods.parameters.call(warehouseState).warehouseId, 'B', '切仓后指标请求参数必须带当前仓库(E1/F1 同源)');
- assert.equal(page.methods.parameters.call(warehouseState).dashboardView, undefined, '指标请求不得混入 dashboardView(那是路由视图参数)');
- assert.equal(page.methods.applyDefaultUnit, undefined, '默认单位链路必须整条删除:applyDefaultUnit 不再存在');
- warehouseState.$route.query = { dashboardView: 'home' };
- page.methods.readRoute.call(warehouseState);
- assert.equal(warehouseState.homeFilters.unit, undefined, '没有显式单位时也不再有默认单位兜底');
- warehouseState.view = 'dead'; warehouseState.filters = { warehouseId: 'B', categoryId: '12', keyword: '批次' };
- warehouseState.homeFilters = { warehouseId: '' };
- warehouseState.route = (view, filters) => { warehouseState.target = { view, filters }; };
- page.methods.open.call(warehouseState, 'home');
- assert.equal(warehouseState.target.filters.categoryId, undefined, '列表分类不得反写首页');
- assert.equal(warehouseState.target.filters.keyword, undefined, '列表关键词不得反写首页');
- assert.equal(warehouseState.target.filters.unit, undefined, '返回首页不补单位:单位维度已随后端契约删除');
- const searchState = { view: 'dead', $route: { query: { dashboard: '1', dashboardView: 'dead' } }, refresh() { this.refreshed = true; }, route() { this.navigated = true; } };
- page.methods.search.call(searchState, {});
- assert.equal(searchState.refreshed, true, '同条件查询必须刷新');
- assert.equal(searchState.navigated, undefined, '同条件无需重复导航');
- console.log('H1 筛选断言通过:切仓清旧值、首页快照只剩仓库、默认单位链路已删除、同条件刷新。');
- // —— I1 盘点工单详情下钻:必须带 planId,且不得把首页筛选整包塞进业务页 URL ——
- let pushed = null;
- const navState = {
- filters: { startTime: '2026-10-01 00:00:00', endTime: '2026-10-31 23:59:59', page: '1', warehouseId: '2103077489545842690', unit: 'KG', categoryId: '2082647086249619457' },
- $router: { push(target) { pushed = target; return Promise.resolve(); } },
- $message: { error(message) { throw new Error(message); } }
- };
- // cleanQuery 在 vm 上下文里执行,返回对象与本上下文原型不同,deepEqual 会误报,统一用 JSON 串比对。
- const sameQuery = (actual, expected, message) => assert.equal(JSON.stringify(actual), JSON.stringify(expected), message);
- page.methods.navigate.call(navState, '/warehouseManagement/stocktaking/work/details', { id: '2115696383397093378', planId: '2115696383174795265' });
- sameQuery(pushed.query, { id: '2115696383397093378', planId: '2115696383174795265' },
- '盘点工单详情 URL 只允许 id 与 planId:首页的 startTime/endTime/page/unit/categoryId/warehouseId 一个都不该带进去');
- assert.equal(pushed.path, '/warehouseManagement/stocktaking/work/details');
- pushed = null;
- page.methods.navigate.call(navState, '/warehouseManagement/outgoingManagement/details', { id: '2115696383397093378', planId: undefined });
- sameQuery(pushed.query, { id: '2115696383397093378' }, '没有 planId 的入口(旧数据/旧链接)不得拼出 planId=undefined');
- let businessPush = null;
- const businessState = {
- navigate(path, query) { businessPush = { path, query }; },
- open() {}, portal() {}, filters: {},
- $refs: { actions: { open() {} } },
- $message: { warning() {}, error() {} }
- };
- businessPush = null;
- page.methods.business.call(businessState, 'todo', { type: 'inventory', id: '2115696383397093378', planId: '2115696383174795265' });
- assert.equal(businessPush.path, '/warehouseManagement/stocktaking/work/details');
- sameQuery(businessPush.query, { id: '2115696383397093378', planId: '2115696383174795265' },
- '待办「盘点任务进行中」下钻必须同时带 id(planOrderId) 与 planId,否则详情页拿不到计划信息');
- businessPush = null;
- page.methods.business.call(businessState, 'io', { activityType: 'inventory', orderId: '2115696383397093378', planId: '2115696383174795265' });
- assert.equal(businessPush.path, '/warehouseManagement/stocktaking/work/details');
- sameQuery(businessPush.query, { id: '2115696383397093378', planId: '2115696383174795265' },
- '出入库动态里的盘点流水下钻同样要带 planId');
- const navigateNoFiltersSource = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard.vue'), 'utf8')).match(/navigate\(path, query = \{\}\)[^\n]*/)[0];
- assert.doesNotMatch(navigateNoFiltersSource, /\.\.\.this\.filters/, 'navigate 不得再整包透传首页筛选(this.filters)到业务页 URL');
- console.log('I1 盘点工单详情下钻断言通过:待办/动态两个入口都带 id+planId、planId 缺失时不拼 undefined、下钻 URL 只保留显式参数(首页 startTime/endTime/page/unit/categoryId/warehouseId 不再进业务页)。');
- // —— J1 「出入库动态 › 查看动态」必须跳系统菜单真实路由 warehouseManagement/inboundRequests ——
- // 不是首页内嵌的 ioapp 视图,也不是自建 V4 动态列表:用户要找的是「出入库申请」这张菜单页本身。
- const homeTplSource = fs.readFileSync(path.join(folder, 'components/HomeOverview.vue'), 'utf8');
- const trendLink = (homeTplSource.match(/<a\b[^>]*>查看动态 ›<\/a>/) || [])[0] || '';
- assert.ok(trendLink, '「查看动态 ›」入口必须存在');
- assert.match(trendLink, /\$emit\('navigate', '\/warehouseManagement\/inboundRequests', \{ warehouseId: warehouseId \}\)/,
- '「查看动态 ›」必须发 navigate(\'/warehouseManagement/inboundRequests\', { warehouseId }):跳菜单真实路由,而不是内嵌 ioapp 视图');
- assert.doesNotMatch(trendLink, /\$emit\('open', 'ioapp'/, '不得再用内嵌 ioapp 视图顶替菜单页');
- assert.doesNotMatch(trendLink, /\$emit\('open', 'io'\)/, '也不得落到自建 V4 动态列表');
- const dashboardTplSource = fs.readFileSync(path.join(folder, 'dashboard.vue'), 'utf8');
- const homeOverviewTag = (dashboardTplSource.match(/<home-overview\b[^>]*>/) || [])[0] || '';
- assert.match(homeOverviewTag, /@navigate="navigate"/, 'dashboard.vue 必须把 home-overview 的 navigate 事件接到 navigate(),否则点「查看动态」无反应');
- let routePushed = null;
- const routeState = {
- $route: { path: '/warehouseManagement/index', query: {} },
- $router: { push(target) { routePushed = target; return Promise.resolve(); } },
- $message: { error(message) { throw new Error(message); } }
- };
- page.methods.navigate.call(routeState, '/warehouseManagement/inboundRequests', { warehouseId: '2103077489545842690' });
- assert.equal(routePushed.path, '/warehouseManagement/inboundRequests', '必须跳真实菜单路由,路径与系统菜单一致');
- sameQuery(routePushed.query, { warehouseId: '2103077489545842690' }, '只带当前仓库,状态/时间/页签交给目标页默认值');
- assert.ok(!('dashboard' in routePushed.query), '跳菜单页不得再带 dashboard=1:会误开看板批量收货勾选列');
- routePushed = null;
- page.methods.navigate.call(routeState, '/warehouseManagement/inboundRequests', { warehouseId: '' });
- sameQuery(routePushed.query, {}, '未选仓库(全部授权仓库)时 query 必须为空,不能塞空串或首页筛选');
- const allLink = (homeTplSource.match(/<a\b[^>]*>全部动态 ›<\/a>/) || [])[0] || '';
- assert.match(allLink, /\$emit\('open', 'io'\)/, '「全部动态 ›」仍落 V4 动态列表,不被本次改动带走');
- console.log('J1 出入库动态入口断言通过:「查看动态 ›」发 navigate(\'/warehouseManagement/inboundRequests\', { warehouseId }),dashboard.vue 已接 @navigate,跳真实菜单路由(独立页签)、只带仓库、不带 dashboard=1;「全部动态 ›」与趋势柱体仍落 V4 动态列表。');
- // —— K1 首页首屏遮罩:数据回来之前不显示内容,且只在首屏出现一次 ——
- const dashSource = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard.vue'), 'utf8'));
- const maskTag = (dashSource.match(/<div\b[^>]*class="home-loading"[^>]*>/) || [])[0] || '';
- assert.ok(maskTag, 'dashboard.vue 必须有首屏遮罩节点(.home-loading)');
- assert.match(maskTag, /v-if="homeLoading && view === 'home'"/, '遮罩只能在首页视图且 homeLoading 为真时出现:明细视图有自己的 v-loading,不能被这块盖住');
- assert.ok(dashSource.includes('正在加载首页数据'), '遮罩必须给出中文加载文案,不能只放一个转圈');
- assert.equal(page.data().homeLoading, true, 'homeLoading 必须默认 true:首屏还没请求就不能先渲染空卡片');
- const createdBlock = dashSource.slice(dashSource.indexOf('async created()'), dashSource.indexOf('activated()'));
- assert.match(createdBlock, /this\.homeLoading = false;/, 'created 里首屏(筛选项 + 汇总)结束后必须撤掉遮罩');
- assert.ok(createdBlock.indexOf('this.homeLoading = false') > createdBlock.indexOf('await this.refresh()'), '必须先 await refresh() 再撤遮罩,否则数据还没到就露出来了');
- // 切仓库会把卡片数据整块清空:这一轮 refresh 必须自己撤遮罩(不能只靠 created 那一次),
- // 否则遮罩会从「切仓库时该出现」变成「永久盖住页面」。
- const readRouteSource = dashSource.slice(dashSource.indexOf('readRoute()'), dashSource.indexOf('route(view, filters'));
- assert.match(readRouteSource, /if \(this\.view === 'home'\) this\.homeLoading = true;/, '切仓库清空数据后必须立刻盖遮罩,否则用户看到的是一片没有任何提示的空白');
- const refreshSource = dashSource.slice(dashSource.indexOf('async refresh()'), dashSource.indexOf('async loadSummary()'));
- assert.match(refreshSource, /finally\s*\{[\s\S]*?this\.homeLoading = false;/, 'refresh 必须在 finally 里撤遮罩:筛选项失败、指标失败、提前 return 都要走到');
- assert.match(refreshSource, /if \(this\.active && generation === this\.generation\) this\.homeLoading = false;/, '撤遮罩必须带 generation 守卫:被新一轮取代的旧请求不能提前揭开空卡片');
- assert.equal((dashSource.match(/this\.homeLoading = false/g) || []).length, 2, '撤遮罩只允许两处:首屏 created 与 refresh 的 finally,别处不得乱撤');
- const layoutScss = stripCodeComments(fs.readFileSync(path.join(folder, 'dashboard-layout.scss'), 'utf8'));
- assert.match(layoutScss, /\.wms-home\s*\{[^}]*position:\s*relative/, '.wms-home 必须是定位上下文,否则遮罩会跑去页面别处');
- assert.match(layoutScss, /\.wms-home \.home-loading\s*\{[^}]*position:\s*absolute/, '遮罩必须绝对定位在内容区内');
- assert.doesNotMatch(layoutScss, /\.wms-home \.home-loading\s*\{[^}]*position:\s*fixed/, '遮罩不得用 fixed:会把系统页头、菜单、标签栏一起盖掉');
- assert.match(layoutScss, /\.wms-home \.home-loading\s*\{[^}]*z-index:\s*\d+/, '遮罩必须显式抬层级,否则盖不住卡片');
- assert.match(layoutScss, /@keyframes\s+home-loading-spin\s*\{[\s\S]{0,120}?rotate\(360deg\)/, '转圈动画必须存在,否则 spinner 静态不转');
- console.log('K1 首页首屏遮罩断言通过:homeLoading 默认 true、created 中 await refresh() 之后置 false,切仓库清空数据时重新置 true 并由 refresh 的 finally(带 generation 守卫)撤掉;遮罩仅在首页视图出现并带中文文案;样式为 .wms-home 内的 absolute 遮罩(非 fixed,不盖系统页头/菜单)+ z-index + 转圈关键帧。');
- // 首页指标拆分:每张卡/图一条路由,限流并保持单项失败隔离。
- const metricCalls = [];
- let runningMetrics = 0;
- let peakMetrics = 0;
- const { value: metricPage, context: metricContext } = load('dashboard.vue', {
- HomeOverview: {}, DashboardDetail: {}, DashboardActions: {}, ...utils,
- screens: vm.runInContext('screens', screens),
- homeSummaryMetric: async (metric) => {
- metricCalls.push(metric);
- peakMetrics = Math.max(peakMetrics, ++runningMetrics);
- await Promise.resolve();
- runningMetrics--;
- if (metric === 'C2') throw new Error('缺少成本');
- return metric === 'C1' ? { inventoryBatchCount: 12, capturedAt: '2026-11-07 12:00:00' } : {};
- }
- });
- const metricNames = Object.keys(vm.runInContext('metricKeys', metricContext));
- assert.equal(metricNames.length, 14, '13 项首页指标和 C6 明细须各有一条指标路由');
- const metricApiSource = fs.readFileSync(path.join(root, 'src/api/warehouseManagement/dashboard.js'), 'utf8');
- assert.match(metricApiSource, /home-summary\/metric\/\$\{metric\}/, '指标 API 必须带编号路径');
- assert.doesNotMatch(metricApiSource, /export const homeSummary\s*=/, '页面停用后应移除旧整包请求入口');
- assert.doesNotMatch(dashboardTplSource, /homeSummarySection/, '首页不得再调用七模块汇总接口');
- (async () => {
- const state = {
- generation: 1, requests: {}, active: true, summary: {}, error: '', updatedAt: '',
- parameters() { return { warehouseId: '1' }; }
- };
- await metricPage.methods.loadSummary.call(state);
- assert.equal(metricCalls.join(','), metricNames.filter(metric => metric !== 'C6').join(','), '首页仅请求 13 项,不请求 C6');
- assert.ok(peakMetrics <= 4, '首页统计并发不得超过 4');
- assert.equal(state.summary.inventoryBatchCount, 12, 'C1 数据须独立落入首页');
- assert.equal(state.summary.inventoryValue, undefined, 'C2 失败不得伪造金额');
- assert.match(state.error, /C2:缺少成本/, '单项失败应标明指标编号');
- const qcState = { generation: 1, requests: {}, active: true, view: 'qc', summary: {}, error: '', updatedAt: '', parameters() { return {}; } };
- metricCalls.length = 0;
- await metricPage.methods.loadSummary.call(qcState);
- assert.equal(metricCalls.filter(metric => metric === 'C6').length, 1, '质检明细保留 C6 数据');
- console.log('首页指标拆分断言通过:13 项独立请求、质检明细保留 C6、并发不超过 4,C2 失败不覆盖 C1。');
- })().catch(error => { console.error(error); process.exitCode = 1; });
- // —— K2 切仓库遮罩:清空即盖、本轮落定才撤、别的刷新不闪 ——
- // dashboard.vue 的 readRoute/refresh 在 load() 里是真实方法,这里用桩驱动,验证的是遮罩状态机而不是源码字符串。
- (async () => {
- const loadingBindings = () => ({
- HomeOverview: {}, DashboardDetail: {}, DashboardActions: {}, ...utils,
- screens: vm.runInContext('screens', screens)
- });
- const makeState = (page, overrides = {}) => ({
- active: true, generation: 0, requests: {}, options: {}, optionsLoaded: false, summary: {}, result: {}, error: '',
- updatedAt: '', loading: false, view: 'home', warehouseId: '', filters: {}, homeFilters: null, homeLoading: false,
- $route: { query: {} },
- loadSummary: page.methods.loadSummary,
- parameters() { return this.filters; },
- ...overrides
- });
- const calls = { metrics: 0 };
- const { value: loadingPage } = load('dashboard.vue', {
- ...loadingBindings(),
- homeOptions: async () => ({ warehouses: [{ id: '1' }, { id: '2' }] }),
- homeSummaryMetric: async () => { calls.metrics++; return { inventoryBatchCount: 1, capturedAt: '2026-11-09 10:00:00' }; }
- });
- // 1) 切仓库:readRoute 清空数据后立刻盖遮罩,本轮 13 项指标落定才撤
- const switched = makeState(loadingPage, { $route: { query: { dashboard: '1', dashboardView: 'home', warehouseId: '2' } } });
- loadingPage.methods.readRoute.call(switched);
- assert.equal(switched.warehouseId, '2');
- assert.equal(switched.homeLoading, true, '切仓库清空数据后必须立刻盖遮罩,否则用户看到的是一片空白');
- await loadingPage.methods.refresh.call(switched);
- assert.equal(switched.homeLoading, false, '这一轮指标全部落定后必须撤掉遮罩');
- assert.ok(calls.metrics > 0, '切仓库必须真的重新请求首页指标');
- assert.equal(switched.summary.inventoryBatchCount, 1, '撤遮罩时数据必须已经落到 summary');
- // 2) 同一仓库重复选择:不清数据,不闪遮罩
- const same = makeState(loadingPage, { warehouseId: '2', summary: { inventoryBatchCount: 1 }, $route: { query: { dashboard: '1', dashboardView: 'home', warehouseId: '2' } } });
- loadingPage.methods.readRoute.call(same);
- assert.equal(same.homeLoading, false, '同仓库重复选择不清空数据,不得闪遮罩');
- // 3) 15 分钟定时刷新 / 手动重试:直接调 refresh,不经过 readRoute,不盖遮罩
- const timer = makeState(loadingPage, { warehouseId: '2', optionsLoaded: true, summary: { inventoryBatchCount: 1 } });
- await loadingPage.methods.refresh.call(timer);
- assert.equal(timer.homeLoading, false, '定时刷新与手动重试不闪遮罩');
- // 4) 筛选项失败(refresh 里提前 return 的分支):遮罩同样要撤,交给错误条 + 重试
- const { value: optionsFailPage } = load('dashboard.vue', {
- ...loadingBindings(),
- homeOptions: async () => { throw new Error('筛选项接口挂了'); },
- homeSummaryMetric: async () => ({})
- });
- const optionsFail = makeState(optionsFailPage, { homeLoading: true, warehouseId: '2' });
- await optionsFailPage.methods.refresh.call(optionsFail);
- assert.equal(optionsFail.homeLoading, false, '筛选项加载失败也必须撤遮罩,不能永久盖住');
- assert.match(optionsFail.error, /筛选项接口挂了/, '筛选项失败要把原因交给错误条');
- // 5) 13 项指标全部失败:遮罩撤掉,错误条接管
- const { value: metricFailPage } = load('dashboard.vue', {
- ...loadingBindings(),
- homeOptions: async () => ({ warehouses: [] }),
- homeSummaryMetric: async () => { throw new Error('指标接口挂了'); }
- });
- const metricFail = makeState(metricFailPage, { homeLoading: true, warehouseId: '2' });
- await metricFailPage.methods.refresh.call(metricFail);
- assert.equal(metricFail.homeLoading, false, '指标全部失败也必须撤遮罩');
- assert.match(metricFail.error, /指标接口挂了/, '指标失败要把原因交给错误条');
- // 6) 已停用/离开看板(active=false)时 refresh 早退:不许把遮罩状态改坏
- const inactive = makeState(loadingPage, { active: false, homeLoading: true });
- await loadingPage.methods.refresh.call(inactive);
- assert.equal(inactive.homeLoading, true, '看板已停用时不发请求也不动遮罩状态(由下一次 activated 的 refresh 决定)');
- console.log('K2 切仓库遮罩断言通过:切仓库清空数据即盖遮罩、本轮 refresh 落定后撤掉;同仓库重复选择、定时刷新、手动重试都不闪;筛选项失败/指标失败/看板停用各分支都走到 finally,遮罩不会永久留在页面上。');
- })().catch(error => { console.error(error); process.exitCode = 1; });
|