import test from 'node:test'; import assert from 'node:assert/strict'; import fs from 'node:fs'; import ts from 'typescript'; import { overviewQuery, sameTrendScope, overviewTrend, splitMetricsLoad } from '../src/priorityMetrics.ts'; const query = { releaseId: 'r1', year: 2026, view: 'product', trendGranularity: 'month', stage: 'bright', columnFilters: [{ field: 'customer', operator: 'contains', values: ['Acme'], stages: ['bright'] }] }; const tick = () => new Promise(resolve => setImmediate(resolve)); function fixture() { const slots = [], effects = [], requests = []; let index = 0, dirty = false, pending = []; const props = { query, enabled: true, refresh: 0 }; const unauthorized = []; const hooks = { useState(initial) { const n = index++; if (!(n in slots)) slots[n] = initial; return [slots[n], value => { slots[n] = value; dirty = true; }]; }, useEffect(fn, deps) { const n = index++, old = effects[n]; if (!old || deps.some((d, i) => !Object.is(d, old.deps[i]))) pending.push(() => { old?.cleanup?.(); effects[n] = { deps, cleanup: fn() }; }); }, }; const api = { metrics(params, signal) { let resolve, reject; const promise = new Promise((r, j) => { resolve = r; reject = j; }); requests.push({ params, signal, resolve, reject }); return promise; } }; const source = fs.readFileSync(new URL('../src/usePriorityMetrics.ts', import.meta.url), 'utf8'); const code = ts.transpileModule(source.slice(source.indexOf('export function')).replace('export function', 'function'), { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText; const hook = new Function('hooks', 'api', 'overviewQuery', 'splitMetricsLoad', `const {useState,useEffect}=hooks;${code};return usePriorityMetrics;`)(hooks, api, overviewQuery, splitMetricsLoad); const onUnauthorized = error => { unauthorized.push(error); return error.status === 403; }; return { props, requests, unauthorized, render() { let result, count = 0; do { dirty = false; index = 0; pending = []; result = hook(props.query, props.enabled, props.refresh, onUnauthorized, props.forceOverview); pending.forEach(run => run()); assert.ok(++count < 10); } while (dirty); return result; }, unmount() { effects.forEach(e => e?.cleanup?.()); } }; } test('overview retains every source predicate and does not mutate the table query', () => { const small = overviewQuery(query); assert.deepEqual(small, { ...query, view: 'overall' }); assert.equal(query.view, 'product'); assert.equal(small.columnFilters, query.columnFilters); }); test('trend reuse requires the same release, time range, grain, stage and all filters', () => { assert.equal(sameTrendScope(query, { ...query, view: 'overall', month: undefined }), true); for (const changed of [{ month: 1 }, { quarter: 2 }, { monthStart: 2, monthEnd: 5 }, { year: undefined }, { releaseId: 'r2' }, { trendGranularity: 'quarter' }, { stage: 'black' }, { includeUnassigned: false }, { product: 'P1' }, { extraFilters: { order: ['X'] } }, { columnFilters: [] }]) { assert.equal(sameTrendScope(query, { ...query, ...changed }), false, JSON.stringify(changed)); } assert.equal(sameTrendScope(query, Object.fromEntries(Object.entries(query).reverse())), true); }); test('trend adapter uses the exact formal values and performs no rate arithmetic', () => { const value = { release: { id: 'r1' }, context: {}, trend: [{ compositeRate: .123456789 }], coverage: {} }; assert.equal(overviewTrend(value).trend, value.trend); }); test('priority gate opens immediately after the small server aggregate and stays closed while loading', async () => { const f = fixture(); assert.equal(f.render().settled, false); assert.equal(f.requests.length, 1); assert.equal(f.requests[0].params.view, 'overall'); const value = { release: { id: 'r1' }, summary: { compositeRate: .9 }, trend: [] }; f.requests[0].resolve(value); await tick(); const result = f.render(); assert.equal(result.settled, true); assert.equal(result.value, value); f.render(); assert.equal(f.requests.length, 1); f.unmount(); }); test('year switches and refresh invalidate the gate and late old replies cannot replace the new result', async () => { const f = fixture(); f.render(); f.props.query = { ...query, year: 2025 }; assert.equal(f.render().settled, false); assert.equal(f.requests[0].signal.aborted, true); f.requests[0].resolve({ summary: 'old' }); await tick(); assert.equal(f.render().value, null); f.requests[1].resolve({ summary: 'new' }); await tick(); assert.equal(f.render().value.summary, 'new'); f.props.refresh++; assert.equal(f.render().settled, false); assert.equal(f.requests.length, 3); f.unmount(); }); test('overview errors allow the regular query to retry independently', async () => { const f = fixture(); f.render(); f.requests[0].reject(Error('temporary failure')); await tick(); assert.deepEqual(f.render(), { value: null, settled: true, failed: true, split: true }); f.unmount(); }); test('authorization failures do not unlock further requests', async () => { const f = fixture(); f.render(); f.requests[0].reject({ status: 403 }); await tick(); assert.equal(f.render().settled, false); assert.equal(f.unauthorized.length, 1); f.unmount(); }); test('inactive pages neither start requests nor accept late results', async () => { const f = fixture(); f.props.enabled = false; f.render(); assert.equal(f.requests.length, 0); f.props.enabled = true; f.render(); f.props.enabled = false; f.render(); assert.equal(f.requests[0].signal.aborted, true); f.requests[0].resolve({ summary: 'late' }); await tick(); assert.equal(f.render().value, null); f.unmount(); }); test('narrow queries reuse a complete response rather than adding a summary round trip', async () => { for (const change of [{month:2},{quarter:1},{product:'P'},{productSearch:'P'},{view:'department'},{view:'overall'}]) { const f=fixture();f.props.query={...query,...change};const first=f.render(); assert.equal(first.split,false);assert.deepEqual(f.requests[0].params,f.props.query); f.requests[0].resolve({summary:'full',rows:[1],trend:[2]});await tick(); assert.equal(f.render().value.rows.length,1);assert.equal(f.requests.length,1);f.unmount(); } }); test('refresh generations cannot qualify retained old table and trend results as current', () => { const source=name=>fs.readFileSync(new URL(`../src/${name}`,import.meta.url),'utf8'); const general=source('QueryPage.tsx'); const metricExpression=general.match(/const metricKey = useMemo\(\(\) => ([^;]+), \[metricParams, queryRevision[^\]]*\]\);/)[1]; const key=new Function('metricParams','queryRevision',`const productPagingScope=true,productPage={key:'page2'};return ${metricExpression}`); assert.notEqual(key(query,0),key(query,1)); const stage=source('StageProductPage.tsx'); const expression=stage.match(/const queryKey=([^;]+);/)[1]; const stageKey=new Function('applied','revision','refreshKey',`const productPagingScope=true,productPage={key:'page2'};return ${expression}`); assert.notEqual(stageKey(query,0,0),stageKey(query,0,1)); assert.notEqual(stageKey(query,0,0),stageKey(query,1,0)); }); test('paged month and search tables keep their first response small',async()=>{ for(const change of [{month:2},{quarter:1},{productSearch:'P'}]) { const f=fixture();f.props.query={...query,...change};f.props.forceOverview=true; assert.equal(f.render().split,true);assert.equal(f.requests[0].params.view,'overall'); for(const key of Object.keys(change))assert.equal(f.requests[0].params[key],change[key]);f.unmount(); } });