统一全系统资源加载、轻量趋势与缓存恢复

This commit is contained in:
2026-11-02 09:54:01 +08:00
parent 8b8f9b7728
commit b711327c8e
58 changed files with 3150 additions and 661 deletions
@@ -28,11 +28,19 @@ function fixture({ authorize=async()=>{}, load }={}) {
useCallback(fn){cursor++;return fn;},
useEffect(fn,deps){const i=cursor++,old=effects.get(i);if(!old||deps.some((d,j)=>!Object.is(d,old.deps[j])))queued.push(()=>{old?.cleanup?.();effects.set(i,{deps,cleanup:fn()});});},
};
hooks.useDelayedIndicator=(active,delayMs=150)=>{
const [visible,setVisible]=hooks.useState(false);
hooks.useEffect(()=>{
if(!active){setVisible(false);return;}
setVisible(false);const timer=setTimeout(()=>setVisible(true),delayMs);return()=>clearTimeout(timer);
},[active,delayMs]);
return active&&visible;
};
const source=fs.readFileSync(new URL('../src/AnalysisVisuals.tsx',import.meta.url),'utf8');
const componentSource=source.slice(source.indexOf('export function AnalysisVisualCard('),source.indexOf('export function AnalysisVisuals(')).replace('export function','function');
const body=ts.transpileModule(componentSource,{fileName:'component.tsx',compilerOptions:{target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React}}).outputText;
const Component=new Function('React','hooks','runtime',`
const {useState,useRef,useEffect,useCallback}=hooks;
const {useState,useRef,useEffect,useCallback,useDelayedIndicator}=hooks;
const Button='Button',Dropdown='Dropdown',Tag='Tag',Modal='Modal',TableOutlined='TableOutlined',DownloadOutlined='DownloadOutlined',MoreOutlined='MoreOutlined',ChartDataTable='ChartDataTable';
const document={visibilityState:'visible',documentElement:{},addEventListener(){},removeEventListener(){}};
const documentIsHidden=()=>false,visualTheme=()=>({}),visualPeriodSummary=()=>'',visualScopeSummary=()=>'',chartSummary=v=>v.title,analysisVisualTypeLabel=()=>'',visualUnitLabel=()=>'';
+2 -2
View File
@@ -6,10 +6,10 @@ const json = (value: unknown) => new Response(JSON.stringify(value), {headers:{'
window.fetch = async (target) => {
const url = new URL(String(target), location.origin);
if(url.pathname==='/api/auth/me')return json({user:{id:'local-fixture',username:'admin',displayName:'admin',roles:['SYSTEM_ADMIN'],departments:[],groups:[]}});
if(url.pathname==='/api/workspace/state')return json({authRevision:'fixture',dataRevision:'fixture'});
if(url.pathname==='/api/workspace/state')return json({authRevision:'fixture',dataRevision:'fixture',currentReleaseId:'fixture-release'});
if(url.pathname==='/api/options')return json({years:[2026],departments:['工业电机产业部'],groups:['工业电机-VCM'],groupDepartments:{'工业电机-VCM':'工业电机产业部'},products,projectGroupStatus:'READY',projectGroups:[],releases:[{id:'fixture-release',name:'本地验收',status:'PUBLISHED'}]});
if(url.pathname==='/api/filter-fields')return json([]);
if(url.pathname==='/api/metrics') {
if(url.pathname==='/api/metrics'||url.pathname==='/api/metrics/trend') {
const view=url.searchParams.get('view');
const product=url.searchParams.get('product');
let visible=product?rows.filter(r=>r.product===product):rows;
+8 -4
View File
@@ -7,13 +7,13 @@ function fixture() {
const source=fs.readFileSync(process.env.QUERY_CHART_SOURCE || new URL('../src/QueryPage.tsx',import.meta.url),'utf8');
const end=source.includes('export function TrendTable(')?source.indexOf('export function TrendTable('):source.indexOf('function TrendTable(');
const code=source.slice(source.indexOf('export function TrendChart('),end).replace('export function','function');
const slots=new Map(),effects=new Map(),observers=[],charts=[];let cursor=0,dirty=false,queued=[],active=true;
const slots=new Map(),effects=new Map(),observers=[],charts=[];let cursor=0,dirty=false,queued=[],active=true,visible=true;
const node={clientWidth:900,clientHeight:380};
const hooks={useRef(initial){const i=cursor++;if(!slots.has(i))slots.set(i,{current:initial});return slots.get(i);},useState(initial){const i=cursor++;if(!slots.has(i))slots.set(i,initial);return [slots.get(i),v=>{const next=typeof v==='function'?v(slots.get(i)):v;if(!Object.is(next,slots.get(i))){slots.set(i,next);dirty=true;}}];},useCallback(fn,deps){const i=cursor++;const old=slots.get(i);if(!old||deps.some((d,j)=>!Object.is(d,old.deps[j])))slots.set(i,{fn,deps});return slots.get(i).fn;},useEffect(fn,deps){const i=cursor++,old=effects.get(i);if(!old||deps.some((d,j)=>!Object.is(d,old.deps[j])))queued.push(()=>{old?.cleanup?.();effects.set(i,{deps,cleanup:fn()});});}};
hooks.useLayoutEffect=hooks.useEffect;
const ec={init(_node,_theme,opts){const c={opts,options:[],resizes:[],disposed:false,getWidth:()=>c.opts.width??100,getHeight:()=>c.opts.height??380,on(){},resize(o){c.resizes.push(o);},setOption(o){c.options.push(o);},convertToPixel:()=>0,dispose(){c.disposed=true;}};charts.push(c);return c;}};
const prelude=`const {useRef,useState,useEffect,useLayoutEffect,useCallback}=hooks;
const usePageCache=()=>({active:getActive()});
const usePageCache=()=>({active:getActive()}),useResourceVisibility=()=>getActive()&&getVisible();
const Empty=Object.assign('Empty',{PRESENTED_IMAGE_SIMPLE:'simple'});
const MutationObserver=class{observe(){}disconnect(){}},ResizeObserver=class{constructor(fn){this.fn=fn;observers.push(this)}observe(){}disconnect(){this.disconnected=true}};
const document={documentElement:{dataset:{}}},window={matchMedia:()=>({matches:false,addEventListener(){},removeEventListener(){}})};
@@ -22,11 +22,11 @@ function fixture() {
const trendBarWidth=()=>32,hasStageRows=()=>true,stageValue=(r,s,f)=>r[s][f],visibleCompositeRate=()=>.95,visibleStageRate=()=>.97,rateNumber=v=>v*100,numberText=String,escapeTooltipText=String,defectWeightRate=()=>0;
`;
const compiled=ts.transpileModule(prelude+code+'\nreturn TrendChart;',{fileName:'motion.tsx',compilerOptions:{target:ts.ScriptTarget.ES2022,jsx:ts.JsxEmit.React}}).outputText;
const Component=new Function('React','hooks','echarts','getActive','observers',compiled)(React,hooks,ec,()=>active,observers);
const Component=new Function('React','hooks','echarts','getActive','getVisible','observers',compiled)(React,hooks,ec,()=>active,()=>visible,observers);
const stage={qualifiedWeight:90,scrapWeight:10,totalWeight:100,defects:[]};const props={rows:[{month:1,black:stage,bright:stage}],mode:'production',stage:'bright',rateBasis:'original',targetRate:null,onMonth(){}};
function attach(t){if(!t||typeof t!=='object')return;if(t.props?.ref)t.props.ref.current=node;React.Children.forEach(t.props?.children,attach);}
function render(){let n=0;do{cursor=0;dirty=false;queued=[];attach(Component(props));queued.forEach(f=>f());assert.ok(++n<10);}while(dirty);}
return {charts,node,render,setActive(v){active=v;render();},resize(){for(const o of observers)if(!o.disconnected)o.fn();},unmount(){effects.forEach(e=>e.cleanup?.());}};
return {charts,node,render,setVisible(v){visible=v;render();},setActive(v){active=v;render();},resize(){for(const o of observers)if(!o.disconnected)o.fn();},unmount(){effects.forEach(e=>e.cleanup?.());}};
}
test('visible entry uses the actual chart size and enables native vertical bar growth',()=>{
const f=fixture();f.render();const c=f.charts[0];assert.equal(c.opts.width,900);assert.equal(c.opts.height,380);
@@ -37,3 +37,7 @@ test('cached page reentry creates a fresh vertical reveal and never resizes a hi
f.setActive(false);assert.equal(f.charts[0].disposed,true);assert.equal(f.charts.length,1);
f.node.clientWidth=900;f.setActive(true);assert.equal(f.charts.length,2);assert.equal(f.charts[1].opts.width,900);assert.ok(f.charts[1].options.find(o=>o.series).animationDuration>0);f.unmount();
});
test('offscreen chart defers initialization until its region becomes visible',()=>{
const f=fixture();f.setVisible(false);assert.equal(f.charts.length,0);f.setVisible(true);assert.equal(f.charts.length,1);f.unmount();
});
@@ -20,6 +20,7 @@ function fixture(){
const MutationObserver=class{observe(){}disconnect(){}},ResizeObserver=class{observe(){}disconnect(){}};
const document={documentElement:{}},window={matchMedia:()=>({matches:false,addEventListener(){},removeEventListener(){}})};
const usePageCache=()=>({active:true});
const useResourceVisibility=()=>true,useDelayedIndicator=value=>value;
const queryChartTypography=()=>({fontFamily:'sans',numericFamily:'sans',fontSize:12,tooltipFontSize:12});
const getComputedStyle=()=>({getPropertyValue:()=>''}),escapeTooltipText=v=>v,numberText=v=>String(v),chooseError=e=>e.message;
class ApiError extends Error{};
+11 -7
View File
@@ -17,10 +17,11 @@ function policyFixture(api, validate) {
const actions=panel.slice(panel.indexOf(' const save ='),panel.indexOf(' const scopeCounts'));
return new Function('api','validate',transpile(`
let userId,policy=null,effective=null,scopePreview=null,previewBusy=false,loading=false,saving=false,error='',fields={};
const active=true,policyRequest={current:null},policyRead={run:async work=>{loading=true;try{return await work();}finally{loading=false;}}};
const selectedUser={current:undefined},policyGeneration={current:0},savingRef={current:false},mounted={current:true};
const obj=v=>v,text=(v,f)=>v??f,onUnauthorized=()=>false,message={success(){},error(){}};
const useCallback=fn=>fn,obj=v=>v,text=(v,f)=>v??f,onUnauthorized=()=>false,message={success(){},error(){}};
class ApiError extends Error{}
const form={resetFields(){fields={};},setFieldsValue(v){fields={...fields,...v};},async validateFields(){return validate?validate():{...fields,reason:'fixture reason'};}};
const form={isFieldsTouched:()=>false,resetFields(){fields={};},setFieldsValue(v){fields={...fields,...v};},async validateFields(){return validate?validate():{...fields,reason:'fixture reason'};}};
const setUserId=v=>userId=v,setPolicy=v=>policy=v,setEffective=v=>effective=v,setScopePreview=v=>scopePreview=v,
setPreviewBusy=v=>previewBusy=v,setLoading=v=>loading=v,setSaving=v=>saving=v,setError=v=>error=v;
${selection}${load}${actions}
@@ -104,7 +105,9 @@ function drawerFixture() {
const requests=[],exports=[];let downloaded=0,refreshKey=0;
const props={open:true,row:null,stage:'black',onStage(){},onClose(){},query:freezeSourceRecordsQuery(baseQuery,'release-A','overall',null),onUnauthorized:()=>false};
const renderer=hookRenderer(hooks=>new Function('React','hooks','api',transpile(`
const {useState,useRef,useMemo,useEffect}=hooks;const usePageCache=()=>({refreshKey:api.refreshKey()});const TABLE_PAGE_SIZE=20,MONTHS=Array.from({length:12},(_,i)=>i+1+'月');
const {useState,useRef,useMemo,useEffect}=hooks;const useLayoutEffect=useEffect;const usePageCache=()=>({active:true,refreshKey:api.refreshKey()});
const useDelayedIndicator=value=>value;
${read('QueryResultMotion.tsx').slice(read('QueryResultMotion.tsx').indexOf('export function useRetainedResult'),read('QueryResultMotion.tsx').indexOf('function numericText')).replace('export function','function')}const TABLE_PAGE_SIZE=20,MONTHS=Array.from({length:12},(_,i)=>i+1+'月');
const Drawer='Drawer',Segmented='Segmented',Select='Select',Button='Button',Alert='Alert',Spin='Spin',Table='Table',Pagination='Pagination',SearchOutlined='SearchOutlined',DownloadOutlined='DownloadOutlined';
const Input='Input',readableSelectPopup={},Empty=Object.assign(()=>null,{PRESENTED_IMAGE_SIMPLE:'empty'}),App={useApp:()=>({message:{success(){},error(){}}})};
const isSystemVersionField=()=>false,chooseError=e=>e.message,withoutSystemVersionFields=v=>v;
@@ -115,11 +118,11 @@ function drawerFixture() {
return {requests,exports,props,render:()=>renderer.render(props),unmount:()=>renderer.unmount(),invalidate(){refreshKey++;},get downloaded(){return downloaded;}};
}
test('actual drawer clears prior rows during page load/failure and offers retry on the same frozen release',async()=>{
test('actual drawer retains prior rows without enabling stale actions and retries the same frozen release',async()=>{
const ui=drawerFixture();ui.render();assert.equal(ui.requests[0].params.page,1);assert.equal(ui.requests[0].params.releaseId,'release-A');
ui.requests[0].resolve({rows:[{id:'A-1',raw:{field:'value'}}],total:45,pageSize:20,page:1});await tick();let tree=ui.render();
assert.equal(find(tree,n=>n.type==='Table').props.dataSource[0].id,'A-1');find(tree,n=>n.type==='Pagination').props.onChange(2);tree=ui.render();
assert.equal(find(tree,n=>n.type==='Table'),undefined);ui.requests[1].reject(Error('page failed'));await tick();tree=ui.render();assert.equal(find(tree,n=>n.type==='Table'),undefined);
assert.equal(find(tree,n=>n.type==='Table').props.dataSource[0].id,'A-1');assert.equal(find(tree,n=>n.props?.['aria-busy']===true).props.inert,true);ui.requests[1].reject(Error('page failed'));await tick();tree=ui.render();assert.equal(find(tree,n=>n.type==='Table').props.dataSource[0].id,'A-1');assert.equal(find(tree,n=>n.type==='Button'&&textOf(n)==='导出明细 Excel').props.disabled,true);
const alert=find(tree,n=>n.type==='Alert');assert.equal(alert.props.description,'page failed');alert.props.action.props.onClick();ui.render();
assert.equal(ui.requests[2].params.page,2);assert.equal(ui.requests[2].params.releaseId,'release-A');ui.unmount();assert.equal(ui.requests[2].signal.aborted,true);
});
@@ -143,11 +146,12 @@ test('closing and reopening a different month remounts page/search state and ign
test('reopening the same frozen drawer reuses its page until the workspace revision changes',async()=>{
const ui=drawerFixture();ui.render();ui.requests[0].resolve({rows:[{id:'cached'}],total:1,pageSize:20,page:1});await tick();ui.render();
ui.props.open=false;ui.render();ui.props.open=true;let tree=ui.render();assert.equal(ui.requests.length,1);assert.equal(find(tree,n=>n.type==='Table').props.dataSource[0].id,'cached');
ui.invalidate();tree=ui.render();assert.equal(ui.requests.length,2);assert.equal(find(tree,n=>n.type==='Table'),undefined);ui.unmount();
ui.invalidate();tree=ui.render();assert.equal(ui.requests.length,2);assert.equal(find(tree,n=>n.type==='Table').props.dataSource[0].id,'cached');assert.equal(find(tree,n=>n.props?.['aria-busy']===true).props.inert,true);ui.unmount();
});
test('export from the actual drawer keeps the clicked release even after current publication changes',async()=>{
const ui=drawerFixture();ui.render();const tree=ui.render();
const ui=drawerFixture();ui.render();ui.requests[0].resolve({rows:[{id:'export-ready'}],total:1,pageSize:20,page:1});await tick();const tree=ui.render();
assert.equal(find(tree,n=>n.type==='Button'&&textOf(n)==='导出明细 Excel').props.disabled,false);
await find(tree,n=>n.type==='Button'&&textOf(n)==='导出明细 Excel').props.onClick();
assert.equal(ui.exports[0].params.releaseId,'release-A');assert.equal(ui.exports[0].params.month,1);assert.equal(ui.downloaded,1);ui.unmount();
});
@@ -0,0 +1,29 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import ts from 'typescript';
const source = ts.transpileModule(readFileSync(new URL('../src/governanceTabResources.ts', import.meta.url), 'utf8'), {
compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
}).outputText.replace(/export /g, '');
const { governanceResourcesForTab, markGovernanceResourcesStale, markGovernanceResourcesFresh } = new Function(`${source};return { governanceResourcesForTab, markGovernanceResourcesStale, markGovernanceResourcesFresh };`)();
test('governance tabs read only their visible resources, with candidates scoped to changes', () => {
assert.deepEqual(governanceResourcesForTab('coverage'), ['coverage']);
assert.deepEqual(governanceResourcesForTab('protocols'), ['protocols']);
assert.deepEqual(governanceResourcesForTab('changes'), ['changes', 'candidates']);
assert.deepEqual(governanceResourcesForTab('revisions'), ['documents']);
assert.deepEqual(governanceResourcesForTab('unknown'), []);
});
test('maintenance refresh dirties every visited governance resource but only clears the active tab', () => {
let stale = markGovernanceResourcesFresh(markGovernanceResourcesStale({}), ['documents']);
assert.equal(stale.documents, false, 'the revisions tab was already read successfully');
stale = markGovernanceResourcesStale(stale);
stale = markGovernanceResourcesFresh(stale, governanceResourcesForTab('coverage'));
assert.equal(stale.coverage, false, 'the active coverage tab was refreshed');
assert.equal(stale.documents, true, 'the previously visited revisions tab stays dirty until selected');
assert.equal(governanceResourcesForTab('revisions').some(resource => stale[resource]), true);
});
@@ -0,0 +1,38 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import ts from 'typescript';
const source = ts.transpileModule(readFileSync(new URL('../src/importLifecycleGuards.ts', import.meta.url), 'utf8'), {
compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext },
}).outputText.replace(/export /g, '');
const guards = new Function(`${source};return { importIssuePageKey, matchesImportIssuePage, runImportPollFollowup };`)();
test('import issue page identity includes both run and page', () => {
assert.equal(guards.importIssuePageKey('run-a', 2), 'run-a:2');
assert.notEqual(guards.importIssuePageKey('run-a', 2), guards.importIssuePageKey('run-a', 3));
assert.notEqual(guards.importIssuePageKey('run-a', 2), guards.importIssuePageKey('run-b', 2));
assert.equal(guards.matchesImportIssuePage('run-a', 2, 'run-a', 2), true);
assert.equal(guards.matchesImportIssuePage('run-a', 2, 'run-a', 3), false);
assert.equal(guards.matchesImportIssuePage('run-a', 2, 'run-b', 2), false);
});
test('an import poll does not start candidate or issue follow-up reads after the view becomes inactive', async () => {
let active = false;
let followupCalls = 0;
const skipped = await guards.runImportPollFollowup('run-a', () => active, async () => { followupCalls++; });
assert.deepEqual(skipped, { started: false, current: false });
assert.equal(followupCalls, 0);
active = true;
let resolveRead;
const pending = guards.runImportPollFollowup('run-a', () => active, () => {
followupCalls++;
return new Promise(resolve => { resolveRead = resolve; });
});
active = false;
resolveRead({ items: [] });
const stale = await pending;
assert.deepEqual(stale, { started: true, current: false, value: { items: [] } });
assert.equal(followupCalls, 1);
});
@@ -0,0 +1,29 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import { queryForLocation, loadedQueryPeriod } from '../src/queryLoadingScope.ts';
test('automatic current snapshots follow the next workspace release after a reload', () => {
const urlQuery=queryForLocation({year:2026,view:'product',releaseId:'r1'});
const restored=JSON.parse(JSON.stringify(urlQuery));
assert.equal(restored.releaseId,undefined);
assert.equal(restored.releaseId || 'r2','r2');
});
test('explicit historical links stay pinned across reloads and current-release changes', () => {
const restored=JSON.parse(JSON.stringify(queryForLocation({year:2026,view:'product',releaseId:'r2'},'r1')));
assert.equal(restored.releaseId || 'r2','r1');
});
test('failed drilled trends cannot ready a replacement table or enable stale exports', () => {
const stage=fs.readFileSync(new URL('../src/StageProductPage.tsx',import.meta.url),'utf8');
const query=fs.readFileSync(new URL('../src/QueryPage.tsx',import.meta.url),'utf8');
const readyExpression=stage.match(/const tableReady=([^;]+);/)[1];
const stageReady=new Function('current','drilledProduct','trendResponse','trendKey','trendLoading','trendError',`return ${readyExpression}`);
assert.equal(stageReady({},'B',{key:'A'},'B',false,'offline'),false);
assert.equal(stageReady({},'B',{key:'B'},'B',false,''),true);
assert.equal(stageReady({},'',null,'B',false,'offline'),true);
const exportExpression=query.match(/exporting=\{summaryExporting\} exportDisabled=\{([^\n]+)\}/)[1];
const disabled=new Function('queryBusy','summaryBusy','tableReady','summaryMetricsData','drilledProduct','trendLoading','currentTrendError','drilledTrendData','visibleRows',`return ${exportExpression}`);
assert.equal(disabled(false,false,false,{},'B',false,'offline',Array(12).fill({}),[]),true);
});
test('cross-year retained scope has a readable label when year is omitted',()=>{assert.equal(loadedQueryPeriod({}), '全部年份');});
@@ -0,0 +1,43 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import ts from 'typescript';
const compiled = ts.transpileModule(readFileSync(new URL('../src/sourceWorkbookDetection.ts', import.meta.url), 'utf8'), {
compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS },
}).outputText;
const module = { exports: {} };
new Function('exports', compiled)(module.exports);
const { detectSourceWorkbook } = module.exports;
const fields = Object.fromEntries(Object.entries({ black: ['序号', '成品规格', '送电镀重量', '责废总重量'], bright: ['序号', '成品规格', '合格重量', '是否电镀来料/二等品库来料'] })
.map(([stage, names]) => [stage, names.map(name => ({ name, required: true }))]));
const workbook = (sheetName, headers, sheets) => ({ uploadId: 'upload', sourceFile: '10月.xlsx', sheets: sheets.map(sheetName => ({ sheetName })), fields,
preview: { sheetName, headerRow: 1, headers, sampleRows: [] } });
test('bright detail following a summary is selected from its business columns', async () => {
const sheets = ['合格率报表', '明细', '成品报废'];
const calls = [];
const detail = workbook('明细', fields.bright.map(x => x.name), sheets);
const result = await detectSourceWorkbook(workbook(sheets[0], ['成品质量统计表(汇总)'], sheets), fields, async (_, params) => { calls.push(params); return detail; });
assert.equal(result.stage, 'bright'); assert.equal(result.workbook, detail); assert.equal(calls.length, 1);
assert.equal(calls[0].sheetName, '明细');
});
test('black specification summary is rejected in favor of the complete detail', async () => {
const sheets = ['黑片报废(按规格)', '报废明细'];
const result = await detectSourceWorkbook(workbook(sheets[0], ['成品规格', '合格重量'], sheets), fields,
async () => workbook(sheets[1], fields.black.map(x => x.name), sheets));
assert.equal(result.stage, 'black'); assert.equal(result.workbook.preview.sheetName, '报废明细');
});
test('a complete first sheet needs no further reads; incomplete sheets remain incomplete', async () => {
const complete = workbook('明细', fields.bright.map(x => x.name), ['明细', '汇总']);
assert.equal((await detectSourceWorkbook(complete, fields, async () => { throw Error('unexpected request'); })).workbook, complete);
const partial = workbook('汇总', ['成品规格'], ['汇总', '其他']);
const result = await detectSourceWorkbook(partial, fields, async () => workbook('其他', [], ['汇总', '其他']));
assert.equal(result.workbook, partial); assert.equal(result.workbook.preview.headers.length, 1);
});
test('preview errors propagate instead of silently offering the wrong worksheet', async () => {
await assert.rejects(detectSourceWorkbook(workbook('汇总', [], ['汇总', '明细']), fields, async () => { throw Error('读取失败'); }), /读取失败/);
});
+2 -2
View File
@@ -5,11 +5,11 @@ const fields=[{key:'customer',label:'客户代码',type:'source_value',stages:['
const metric=(qualified:number,scrap:number)=>({qualifiedWeight:qualified,scrapWeight:scrap,totalWeight:qualified+scrap,rate:qualified/(qualified+scrap),headquartersScrapWeight:0,rateWithoutHeadquartersScrap:qualified/(qualified+scrap),defects:[{name:'材料废',weight:scrap*.5,rate:.5},{name:'加工废',weight:scrap*.3,rate:.3},{name:'镀废',weight:scrap*.2,rate:.2}]});
window.fetch=async(target,init)=>{
const url=new URL(String(target),location.origin),path=url.pathname;
if(path==='/api/auth/me')return json({user});if(path==='/api/auth/csrf')return json({token:'local-preview'});if(path==='/api/workspace/state')return json({authRevision:'preview',dataRevision:'preview'});
if(path==='/api/auth/me')return json({user});if(path==='/api/auth/csrf')return json({token:'local-preview'});if(path==='/api/workspace/state')return json({authRevision:'preview',dataRevision:'preview',currentReleaseId:'preview-published'});
if(path==='/api/options')return json({years:[2026],departments:['汽车交通产业部','工业电机产业部'],groups:['汽车交通-国内','汽车交通-海外','工业电机-中国区'],products:['P001 磁钢','P002 磁环'],projectGroupStatus:'READY',projectGroups:['新能源汽车'],groupDepartments:{'汽车交通-国内':'汽车交通产业部','汽车交通-海外':'汽车交通产业部','工业电机-中国区':'工业电机产业部'},organizationPaths:[{department:'汽车交通产业部',group:'汽车交通-国内',product:'P001 磁钢'},{department:'工业电机产业部',group:'工业电机-中国区',product:'P002 磁环'}]});
if(path==='/api/analysis/source/catalog')return json({releaseId:'preview-published',sourceFields:fields});
if(path==='/api/analysis/source/values')return json({values:['0007','0012','0090'],hasMore:false,totalCount:3});
if(path==='/api/metrics'){
if(path==='/api/metrics'||path==='/api/metrics/trend'){
const stage=url.searchParams.get('stage')==='black'?'black':'bright',filters=JSON.parse(url.searchParams.get('columnFilters')||'[]');requests.push({stage,filters,trendGranularity:url.searchParams.get('trendGranularity'),group:url.searchParams.get('group'),department:url.searchParams.get('department')});document.getElementById('request-log')!.textContent=JSON.stringify(requests);
const selected=stage==='black'?metric(900,100):metric(920,80),empty={qualifiedWeight:0,scrapWeight:0,totalWeight:0,rate:null,defects:[]};
const row={key:'P001',label:'P001 磁钢',department:'汽车交通产业部',group:'汽车交通-国内',product:'P001 磁钢',projectGroup:'新能源汽车',black:stage==='black'?selected:empty,bright:stage==='bright'?selected:empty,compositeRate:selected.rate,coverage:{blackRows:stage==='black'?20:0,brightRows:stage==='bright'?20:0}};
+84
View File
@@ -0,0 +1,84 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { createVisiblePollingController } from '../src/visiblePollingController.ts';
function fakeClock() {
let nextId = 0;
let now = 0;
const timers = new Map();
return {
timers,
now: () => now,
setTimeout(callback, delay) { const id = ++nextId; timers.set(id, { at: now + delay, callback }); return id; },
clearTimeout(id) { timers.delete(id); },
advance(ms) {
now += ms;
const due = [...timers.entries()].filter(([, timer]) => timer.at <= now).sort((a, b) => a[1].at - b[1].at);
for (const [id, timer] of due) { timers.delete(id); timer.callback(); }
},
};
}
const flush = async () => { await Promise.resolve(); await Promise.resolve(); };
test('polls serially and waits the full interval after each request settles', async () => {
const clock = fakeClock(); let completeFirst; let calls = 0;
const controller = createVisiblePollingController(() => {
calls++;
if (calls === 1) return new Promise(resolve => { completeFirst = resolve; });
}, 15000, clock);
controller.start(true);
assert.equal(calls, 0);
clock.advance(15000);
await flush();
assert.equal(calls, 1);
clock.advance(60000);
assert.equal(calls, 1, 'an unresolved request prevents overlap');
completeFirst();
await flush();
clock.advance(14999);
assert.equal(calls, 1);
clock.advance(1);
await flush();
assert.equal(calls, 2);
controller.stop();
assert.equal(clock.timers.size, 0);
});
test('pauses while hidden and immediately checks on resume without overlapping an in-flight read', async () => {
const clock = fakeClock(); let release; let calls = 0; let concurrent = 0; let maxConcurrent = 0;
const controller = createVisiblePollingController(async () => {
calls++; concurrent++; maxConcurrent = Math.max(maxConcurrent, concurrent);
if (calls === 1) await new Promise(resolve => { release = resolve; });
concurrent--;
}, 2000, clock);
controller.start(false, true);
assert.equal(calls, 0);
controller.setVisible(true);
await flush();
assert.equal(calls, 1);
controller.setVisible(false);
controller.setVisible(true);
await flush();
assert.equal(calls, 1, 'visibility return queues an immediate read behind the active request');
release();
await flush();
await flush();
assert.equal(calls, 2);
assert.equal(maxConcurrent, 1);
controller.stop();
assert.equal(clock.timers.size, 0);
});
test('stopping polling leaves the current request alone and prevents future scheduling', async () => {
const clock = fakeClock(); let release; let calls = 0;
const controller = createVisiblePollingController(() => { calls++; return new Promise(resolve => { release = resolve; }); }, 5000, clock);
controller.start(true);
clock.advance(5000);
await flush();
controller.stop();
release();
await flush();
assert.equal(clock.timers.size, 0);
clock.advance(50000);
assert.equal(calls, 1);
});
@@ -0,0 +1,244 @@
import assert from 'node:assert/strict';
import { createRequire } from 'node:module';
import { readFile } from 'node:fs/promises';
import { test } from 'node:test';
const require = createRequire(import.meta.url);
const ts = require('typescript');
const sourcePath = new URL('../src/requestCoordinator.ts', import.meta.url);
async function loadCoordinator() {
const source = await readFile(sourcePath, 'utf8');
const compiled = ts.transpileModule(source, {
compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
}).outputText;
return import(`data:text/javascript;base64,${Buffer.from(compiled).toString('base64')}#${Date.now()}-${Math.random()}`);
}
const tick = () => new Promise(resolve => setTimeout(resolve, 0));
const result = data => ({ data, status: 200, bytes: Buffer.byteLength(JSON.stringify(data)) });
test('same scoped GET and normalized query share one execution', async () => {
const coordinator = await loadCoordinator();
let runs = 0;
let finish;
const execute = () => {
runs += 1;
return new Promise(resolve => { finish = () => resolve(result({ value: 7 })); });
};
const first = coordinator.coordinateRequest({ url: '/api/metrics?b=2&a=1', execute });
const second = coordinator.coordinateRequest({ url: '/api/metrics?a=1&b=2', execute });
await tick();
assert.equal(runs, 1);
finish();
assert.deepEqual(await Promise.all([first, second]), [{ value: 7 }, { value: 7 }]);
});
test('one subscriber can cancel without aborting the shared GET for another', async () => {
const coordinator = await loadCoordinator();
const left = new AbortController();
const right = new AbortController();
let networkSignal;
let finish;
const execute = signal => {
networkSignal = signal;
return new Promise(resolve => { finish = () => resolve(result('ok')); });
};
const first = coordinator.coordinateRequest({ url: '/api/metrics?x=1', signal: left.signal, execute });
const second = coordinator.coordinateRequest({ url: '/api/metrics?x=1', signal: right.signal, execute });
await tick();
left.abort();
await assert.rejects(first, error => error.name === 'AbortError');
assert.equal(networkSignal.aborted, false);
finish();
assert.equal(await second, 'ok');
});
test('a cancelled queued GET never starts and an active read starts before background work', async () => {
const coordinator = await loadCoordinator();
const started = [];
const releases = new Map();
const execute = label => signal => {
started.push(label);
return new Promise((resolve, reject) => {
releases.set(label, () => resolve(result(label)));
signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')), { once: true });
});
};
const active = Array.from({ length: 4 }, (_, index) => coordinator.coordinateRequest({ url: `/hold/${index}`, execute: execute(`hold-${index}`) }));
await tick();
assert.equal(started.length, 4);
const queued = new AbortController();
const cancelled = coordinator.coordinateRequest({ url: '/queued/cancel', signal: queued.signal, execute: execute('cancelled') });
const background = coordinator.coordinateRequest({ url: '/queued/background', priority: 'background', execute: execute('background') });
const foreground = coordinator.coordinateRequest({ url: '/queued/foreground', priority: 'active', execute: execute('foreground') });
queued.abort();
await assert.rejects(cancelled, error => error.name === 'AbortError');
releases.get('hold-0')();
const waitForStart = async label => {
const expires = Date.now() + 1_000;
while (!started.includes(label) && Date.now() < expires) await tick();
assert.ok(started.includes(label), `${label} did not start`);
};
await waitForStart('foreground');
assert.equal(started[4], 'foreground');
releases.get('foreground')();
await waitForStart('background');
releases.get('background')();
for (const label of ['hold-1', 'hold-2', 'hold-3']) releases.get(label)();
await Promise.all([...active, background, foreground]);
assert.equal(started.includes('cancelled'), false);
});
test('retry is limited to one and the one second backoff counts against the request budget', async () => {
const coordinator = await loadCoordinator();
let runs = 0;
const started = Date.now();
await assert.rejects(coordinator.coordinateRequest({
url: '/api/metrics', timeoutMs: 35,
execute: async () => { runs += 1; throw Object.assign(new Error('unavailable'), { status: 503 }); },
}), error => error.name === 'RequestTimeoutError');
assert.equal(runs, 1);
assert.ok(Date.now() - started < 500);
});
test('a successful read retries a transient gateway failure exactly once after one second', async () => {
const coordinator = await loadCoordinator();
let runs = 0;
const started = Date.now();
const value = await coordinator.coordinateRequest({
url: '/api/metrics', timeoutMs: 2500,
execute: async () => {
runs += 1;
if (runs === 1) throw Object.assign(new Error('gateway'), { status: 502 });
return result('recovered');
},
});
assert.equal(value, 'recovered');
assert.equal(runs, 2);
assert.ok(Date.now() - started >= 950);
});
test('response body work is covered by the deadline and authorization failures are not retried', async () => {
const coordinator = await loadCoordinator();
let bodyRuns = 0;
await assert.rejects(coordinator.coordinateRequest({
url: '/api/metrics/body', timeoutMs: 20,
execute: signal => {
bodyRuns += 1;
return new Promise((_, reject) => signal.addEventListener('abort', () => reject(new DOMException('Aborted', 'AbortError')), { once: true }));
},
}), error => error.name === 'RequestTimeoutError');
assert.equal(bodyRuns, 1);
let deniedRuns = 0;
await assert.rejects(coordinator.coordinateRequest({
url: '/api/private', execute: async () => { deniedRuns += 1; throw Object.assign(new Error('denied'), { status: 401 }); },
}), error => error.status === 401);
assert.equal(deniedRuns, 1);
let writeRuns = 0;
await assert.rejects(coordinator.coordinateRequest({
url: '/api/sources', method: 'POST', execute: async () => { writeRuns += 1; throw Object.assign(new Error('gateway'), { status: 503 }); },
}), error => error.status === 503);
assert.equal(writeRuns, 1);
});
test('cache is LRU bounded, scoped to the tenant, and invalidated by tags', async () => {
const coordinator = await loadCoordinator();
coordinator.configureRequestScope({ userId: 'u1', authRevision: 'a1', dataRevision: 'd1', currentReleaseId: 'r1' });
let runs = 0;
const fetchValue = url => coordinator.coordinateRequest({ url, cache: true, tags: ['metrics'], execute: async () => {
runs += 1;
return result({ payload: 'x'.repeat(11 * 1024 * 1024), version: runs });
} });
await fetchValue('/api/metrics?a=1');
await fetchValue('/api/metrics?a=2');
await fetchValue('/api/metrics?a=3');
await fetchValue('/api/metrics?a=2');
assert.equal(runs, 3);
await fetchValue('/api/metrics?a=1');
assert.equal(runs, 4);
coordinator.configureRequestScope({ userId: 'u2', authRevision: 'a1', dataRevision: 'd1', currentReleaseId: 'r1' });
await fetchValue('/api/metrics?a=2');
assert.equal(runs, 5);
coordinator.invalidateReadResources(['metrics']);
await fetchValue('/api/metrics?a=2');
assert.equal(runs, 6);
});
test('scope changes prevent an old response from resolving or entering the new scope cache', async () => {
const coordinator = await loadCoordinator();
coordinator.configureRequestScope({ userId: 'old', authRevision: '1', dataRevision: '1', currentReleaseId: null });
let finishOld;
const stale = coordinator.coordinateRequest({ url: '/api/metrics', cache: true, tags: ['metrics'], execute: () => new Promise(resolve => { finishOld = () => resolve(result('old')); }) });
await tick();
coordinator.configureRequestScope({ userId: 'new', authRevision: '1', dataRevision: '1', currentReleaseId: null });
await assert.rejects(stale, error => error.name === 'AbortError');
finishOld();
let newRuns = 0;
const readNew = () => coordinator.coordinateRequest({ url: '/api/metrics', cache: true, tags: ['metrics'], execute: async () => { newRuns += 1; return result('new'); } });
assert.equal(await readNew(), 'new');
assert.equal(await readNew(), 'new');
assert.equal(newRuns, 1);
});
test('security cache clearing keeps unrelated in-flight reads alive and blocks their stale cache write', async () => {
const coordinator = await loadCoordinator();
let finish;
let runs = 0;
const read = () => coordinator.coordinateRequest({
url: '/api/options', cache: true, tags: ['options'],
execute: async () => {
runs += 1;
if (runs === 1) return new Promise(resolve => { finish = () => resolve(result('already-authorized')); });
return result('fresh');
},
});
const active = read();
await tick();
coordinator.clearReadCache();
finish();
assert.equal(await active, 'already-authorized');
assert.equal(await read(), 'fresh');
assert.equal(runs, 2);
const diagnostic = coordinator.getRequestDiagnostics().at(-1);
assert.deepEqual(Object.keys(diagnostic).sort(), ['bytes', 'category', 'elapsedMs', 'retries', 'status']);
});
test('a file read outside the data queue is cancelled when its owning account changes', async () => {
const coordinator = await loadCoordinator();
coordinator.configureRequestScope({ userId: 'old', authRevision: '1', dataRevision: '1', currentReleaseId: 'r' });
let finish, signal;
const file = coordinator.coordinateRequest({
url: '/api/records/export', queue: false, retry: false, timeoutMs: 1000,
execute: current => { signal = current; return new Promise(resolve => { finish = () => resolve(result('old-user-file')); }); },
});
const outcome = file.then(value => ({ value }), error => ({ error }));
coordinator.configureRequestScope({ userId: 'new', authRevision: '1', dataRevision: '1', currentReleaseId: 'r' });
finish();
const settled = await outcome;
assert.equal(signal.aborted, true);
assert.equal(settled.error?.name, 'AbortError');
assert.equal(settled.value, undefined);
});
test('a dropped response body is retried once as a network read failure', async () => {
const coordinator = await loadCoordinator();
let runs = 0;
const value = await coordinator.coordinateRequest({
url: '/api/metrics/trend', timeoutMs: 2500,
execute: async () => {
runs++;
// 浏览器在 headers 已到、正文读取期间断网时抛出 TypeError。
await new Response(new ReadableStream({ start(controller) {
if (runs === 1) controller.error(new TypeError('terminated'));
else { controller.enqueue(new TextEncoder().encode('ok')); controller.close(); }
} })).text();
return result('recovered');
},
});
assert.equal(runs, 2);
assert.equal(value, 'recovered');
});
@@ -0,0 +1,24 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import { pageUsesResources } from '../src/resourceInvalidation.ts';
test('analysis and task changes do not invalidate retained query tables', () => {
for (const page of ['overall', 'department', 'group', 'product', 'blackProduct', 'brightProduct']) {
assert.equal(pageUsesResources(page, ['analysis', 'tasks']), false);
assert.equal(pageUsesResources(page, ['metrics', 'releases']), true);
assert.equal(pageUsesResources(page, ['options']), true);
}
assert.equal(pageUsesResources('tasks', ['tasks']), true);
assert.equal(pageUsesResources('analysis', ['analysis']), true);
});
test('configuration resources wake only dependent editors and unknown writes safely invalidate all', () => {
assert.equal(pageUsesResources('rules', ['configuration']), true);
assert.equal(pageUsesResources('masterData', ['configuration']), true);
assert.equal(pageUsesResources('access', ['policy']), true);
assert.equal(pageUsesResources('sources', ['workflow']), true);
for (const page of ['overall', 'analysis', 'rules', 'access']) {
assert.equal(pageUsesResources(page), true);
assert.equal(pageUsesResources(page, ['*']), true);
}
});
@@ -0,0 +1,88 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import ts from 'typescript';
import React from 'react';
import { readQueryLocation } from '../src/queryLoadingScope.ts';
import { pageUsesResources } from '../src/resourceInvalidation.ts';
const tick = () => new Promise(resolve => setImmediate(resolve));
const deferred = () => { let resolve, reject; const promise = new Promise((a, b) => { resolve = a; reject = b; }); return { promise, resolve, reject }; };
function fixture() {
const source = fs.readFileSync(new URL('../src/CachedWorkspacePages.tsx', import.meta.url), 'utf8')
.replace(/^import[\s\S]*?;\n/gm, '').replace(/export /g, '');
const values = new Map(), refs = new Map(), effects = new Map(), events = new Map(), navigations = [], scopes = [];
let cursor = 0, dirty = false, queued = [], tree;
let state = { authRevision: 'a1', dataRevision: 'd1', currentReleaseId: 'r1' }, failState = false, failStatus, me, optionReads=0, optionDenied=false;
const props = { page: 'overall', user: { id: 'A' }, onUnauthorized: () => false,
onPageChange(page) { props.page = page; dirty = true; }, onUserChange(user) { props.user = user; dirty = true; } };
const ref = { current: null };
const hooks = {
useState(initial) { const i = cursor++; if (!values.has(i)) values.set(i, typeof initial === 'function' ? initial() : initial); return [values.get(i), next => { values.set(i, typeof next === 'function' ? next(values.get(i)) : next); dirty = true; }]; },
useRef(initial) { const i = cursor++; if (!refs.has(i)) refs.set(i, { current: initial }); return refs.get(i); },
useEffect(fn, deps) { const i = cursor++, old = effects.get(i); if (!old || deps.some((value, j) => !Object.is(value, old.deps[j]))) queued.push(() => { old?.cleanup?.(); effects.set(i, { deps, fn, cleanup: fn() }); }); },
useImperativeHandle(target, factory) { cursor++; target.current = factory(); },
};
const api = { async options() { optionReads++; if(optionDenied) { events.get('quality-permission-recheck')?.(); throw Object.assign(Error('denied'),{status:403}); } return {}; }, async sourceColumnCatalog() { return {}; }, async workspaceState() { if (failState) { failState = false; throw Object.assign(Error('temporary-offline'), { status: failStatus }); } return { ...state }; }, async me() { return me ? me.promise : props.user; } };
const env = {
location: { search: '?page=overall', pathname: '/' },
window: { scrollY: 0, scrollTo() {}, matchMedia: () => ({ matches: false }), addEventListener: (name, fn) => events.set(name, fn), removeEventListener: name => events.delete(name) },
document: { visibilityState: 'visible', addEventListener: (name, fn) => events.set(name, fn), removeEventListener: name => events.delete(name), querySelector() {} },
history: { pushState(_state, _title, url) { env.location.search = url.slice(url.indexOf('?')); } },
requestAnimationFrame(fn) { fn(); return 1; }, cancelAnimationFrame() {},
forwardRef: component => component, lazy: () => 'Page', Suspense: 'Suspense', Alert: 'Alert', Button: 'Button', Spin: 'Spin',
PageCacheContext: { Provider: 'Provider' }, WORKSPACE_INVALIDATED: 'invalidate',
configureRequestScope: scope => scopes.push({ ...scope }), resetRequestScope: () => {},
createWorkspaceTransition: () => ({ run(callback) { const promise = callback(new AbortController().signal); navigations.push(promise); }, cancel() {} }),
waitForWorkspaceContent: async () => {}, flushSync: fn => fn(),
};
const prelude = 'const {useState,useRef,useEffect,useImperativeHandle}=hooks;const useLayoutEffect=useEffect;';
const compiled = ts.transpileModule(prelude + source + '\nreturn CachedWorkspacePages;', { fileName: 'fixture.tsx', compilerOptions: { target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.React } }).outputText;
const component = new Function('React', 'hooks', 'api', 'pageUsesResources','readQueryLocation', ...Object.keys(env), compiled)(React, hooks, api, pageUsesResources,readQueryLocation, ...Object.values(env));
const render = () => { let attempts = 0; do { cursor = 0; dirty = false; queued = []; tree = component(props, ref); queued.forEach(fn => fn()); assert.ok(++attempts < 15); } while (dirty); return tree; };
const pages = () => { const result = []; function walk(node) { if (!node || typeof node !== 'object') return; if (node.props?.['data-page']) result.push(node.props['data-page']); React.Children.forEach(node.props?.children, walk); } walk(tree); return result; };
return { render, pages, props, scopes, ref, async start() { render(); await tick(); render(); }, async settle() { await Promise.all(navigations); await tick(); render(); },
getOptionReads:()=>optionReads,denyOptions(){optionDenied=true;},failNextState(status) { failState = true; failStatus = status; }, changeIdentity() { state = { ...state, authRevision: 'b2' }; me = deferred(); return me; },
async focus() { events.get('focus')?.(); await tick(); render(); }, cleanup() { effects.forEach(effect => effect.cleanup?.()); } };
}
test('a navigation rejected by workspace validation can be retried to the same destination', async () => {
const ui = fixture(); await ui.start();
ui.failNextState(); ui.ref.current.navigate('department'); await ui.settle();
assert.equal(ui.props.page, 'overall');
ui.ref.current.navigate('department'); await ui.settle();
assert.equal(ui.props.page, 'department'); ui.cleanup();
});
test('revoked authorization immediately hides retained pages while the latest identity is pending or failed', async () => {
const ui = fixture(); await ui.start(); assert.deepEqual(ui.pages(), ['overall']);
const me = ui.changeIdentity(); await ui.focus();
assert.deepEqual(ui.pages(), []);
me.reject(Error('identity-unavailable')); await tick(); ui.render();
assert.deepEqual(ui.pages(), []); ui.cleanup();
});
test('foreground validation uses the refreshed identity instead of the first mounted user', async () => {
const ui = fixture(); await ui.start(); const me = ui.changeIdentity(); await ui.focus();
me.resolve({ id: 'B' }); await tick(); ui.render();
assert.equal(ui.props.user.id, 'B');
await ui.focus(); assert.equal(ui.scopes.at(-1).userId, 'B'); ui.cleanup();
});
test('workspace 403 hides private retained results and rebuilds after authorization recovery', async () => {
const ui = fixture(); await ui.start(); assert.deepEqual(ui.pages(), ['overall']);
ui.failNextState(403); await ui.focus(); assert.deepEqual(ui.pages(), []);
await ui.focus(); await tick(); ui.render(); assert.deepEqual(ui.pages(), ['overall']); ui.cleanup();
});
test('a first-load workspace 403 can recover into a populated workspace', async () => {
const ui = fixture(); ui.failNextState(403); await ui.start(); assert.deepEqual(ui.pages(), []);
await ui.focus(); await tick(); ui.render(); assert.deepEqual(ui.pages(), ['overall']); ui.cleanup();
});
test('a forbidden options resource does not trigger repeated warm reads during permission rechecks', async () => {
const ui=fixture();ui.denyOptions();await ui.start();await tick();ui.render();const count=ui.getOptionReads();
await ui.focus();await tick();ui.render();assert.equal(ui.getOptionReads(),count);assert.ok(count<=1);ui.cleanup();
});
@@ -1,32 +1,53 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import {readFileSync} from 'node:fs';
import { readFileSync } from 'node:fs';
import ts from 'typescript';
const source=ts.transpileModule(readFileSync(new URL('../src/useDataWorkflowOperation.ts',import.meta.url),'utf8'),{compilerOptions:{target:ts.ScriptTarget.ES2022,module:ts.ModuleKind.ESNext}}).outputText.replace(/^import .*;\n/gm,'').replace(/export /g,'');
const tick=()=>new Promise(resolve=>setImmediate(resolve));
const deferred=()=>{let resolve;const promise=new Promise(done=>{resolve=done;});return{promise,resolve};};
const source = ts.transpileModule(readFileSync(new URL('../src/useDataWorkflowOperation.ts', import.meta.url), 'utf8'), { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext } }).outputText.replace(/^import .*;\n/gm, '').replace(/export /g, '');
const tick = () => new Promise(resolve => setImmediate(resolve));
const deferred = () => { let resolve; const promise = new Promise(done => { resolve = done; }); return { promise, resolve }; };
test('the actual workflow hook refreshes retained data after completion, rather than while work is pending',async()=>{
const final=deferred(),events=[],callbacks=[],storage=new Map();let calls=0;
const window={localStorage:storage,setTimeout:fn=>setImmediate(fn),dispatchEvent:event=>events.push(event.type)};
const localStorage={getItem:key=>storage.get(key)??null,setItem:(key,value)=>storage.set(key,value),removeItem:key=>storage.delete(key)};
const api={dataWorkflowOperation:async()=>++calls===1?{operationId:'job',status:'RUNNING'}:final.promise};
const hooks={useState:value=>[value,()=>{}],useRef:current=>({current}),useCallback:fn=>fn,useEffect:fn=>{fn();}};
const load=new Function('api','window','localStorage','WORKSPACE_INVALIDATED','hooks',`const {useState,useRef,useCallback,useEffect}=hooks;${source};return useDataWorkflowOperation;`);
const hook=load(api,window,localStorage,'quality-workspace-invalidated',hooks)('project',value=>callbacks.push(value));
await hook.start(async()=>({operationId:'job',status:'QUEUED'}));await tick();await tick();
assert.equal(calls,2);assert.deepEqual(events,[]);assert.equal(storage.size,1);
final.resolve({operationId:'job',status:'COMPLETED',currentReleaseId:'new-release'});await tick();
assert.deepEqual(events,['quality-workspace-invalidated']);assert.equal(callbacks[0].currentReleaseId,'new-release');assert.equal(storage.size,0);
function operationHook(api) {
const events = [], callbacks = [], storage = new Map();
const window = { localStorage: storage, dispatchEvent: event => events.push(event) };
const localStorage = { getItem: key => storage.get(key) ?? null, setItem: (key, value) => storage.set(key, value), removeItem: key => storage.delete(key) };
const hooks = { useState: value => [value, () => {}], useRef: current => ({ current }), useCallback: fn => fn, useEffect: fn => { fn(); } };
const load = new Function('api', 'window', 'localStorage', 'WORKSPACE_INVALIDATED', 'usePageCache', 'useVisiblePolling', 'hooks', `const {useState,useRef,useCallback,useEffect}=hooks;${source};return useDataWorkflowOperation;`);
const useDataWorkflowOperation = load(api, window, localStorage, 'quality-workspace-invalidated', () => ({ active: true }), () => {}, hooks);
const hook = useDataWorkflowOperation('project', value => callbacks.push(value));
return { hook, events, callbacks, storage };
}
test('a completed workflow invalidates retained data exactly once after the server marks it complete', async () => {
const final = deferred(); let calls = 0;
const { hook, events, callbacks, storage } = operationHook({ dataWorkflowOperation: async () => { calls++; return final.promise; } });
await hook.start(async () => ({ operationId: 'job', status: 'QUEUED' }));
assert.equal(storage.size, 1, 'the operation id is retained for refresh recovery');
hook.resume(); hook.resume();
await tick();
assert.equal(calls, 1, 'overlapping progress checks are coalesced');
assert.deepEqual(events, []);
final.resolve({ operationId: 'job', status: 'COMPLETED', currentReleaseId: 'new-release' });
await tick(); await tick();
assert.equal(events.length, 1);
assert.equal(events[0].type, 'quality-workspace-invalidated');
assert.deepEqual(events[0].detail.resources, ['sources', 'workflow', 'tasks', 'releases', 'metrics', 'trend', 'records', 'options', 'catalog', 'configuration']);
assert.equal(callbacks.length, 1);
assert.equal(callbacks[0].currentReleaseId, 'new-release');
assert.equal(storage.size, 0);
hook.resume(); await tick();
assert.equal(events.length, 1, 'a terminal result cannot invalidate a second time');
});
test('failed work never refreshes retained data as though a new version had been published',async()=>{
const events=[],callbacks=[];const api={dataWorkflowOperation:async()=>({operationId:'job',status:'FAILED',errors:[{message:'rejected'}]})};
const hooks={useState:value=>[value,()=>{}],useRef:current=>({current}),useCallback:fn=>fn,useEffect:fn=>{fn();}};
const localStorage={getItem:()=>null,setItem:()=>{},removeItem:()=>{}};
const window={setTimeout:fn=>setImmediate(fn),dispatchEvent:event=>events.push(event.type)};
const load=new Function('api','window','localStorage','WORKSPACE_INVALIDATED','hooks',`const {useState,useRef,useCallback,useEffect}=hooks;${source};return useDataWorkflowOperation;`);
const hook=load(api,window,localStorage,'quality-workspace-invalidated',hooks)('project',value=>callbacks.push(value));
await hook.start(async()=>({operationId:'job',status:'QUEUED'}));await tick();assert.deepEqual(events,[]);assert.deepEqual(callbacks,[]);
test('failed workflows never invalidate published data and keep the operation id available for recovery', async () => {
let calls = 0;
const { hook, events, callbacks, storage } = operationHook({ dataWorkflowOperation: async () => { calls++; return { operationId: 'job', status: 'FAILED', errors: [{ message: 'rejected' }] }; } });
await hook.start(async () => ({ operationId: 'job', status: 'QUEUED' }));
hook.resume(); await tick(); await tick();
assert.deepEqual(events, []);
assert.deepEqual(callbacks, []);
assert.equal(storage.size, 1);
hook.resume(); await tick();
assert.equal(calls, 1, 'a terminal failure is not polled repeatedly');
assert.deepEqual(events, []);
});