Files

114 lines
7.5 KiB
JavaScript

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();
}
});