114 lines
7.5 KiB
JavaScript
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();
|
|
}
|
|
});
|