@jrpool/kilotest 58.2.0 → 58.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrpool/kilotest",
-  "version": "58.2.0",
+  "version": "58.2.4",
   "description": "Ensemble testing for front-end web quality",
   "type": "module",
   "main": "index.ts",

package/util.test.ts

@@ -1276,7 +1276,7 @@ test('getIssue returns null for a known engine with an unknown variable rule', (
 });
 
 test('getIssue returns an issue ID for a variable rule pattern match', () => {
-  const result = getIssue('nuVal', 'Duplicate attribute foo');
+  const result = getIssue('nuVal', 'Duplicate attribute foo.');
   assert.ok(typeof result === 'string');
   assert.equal(result, 'duplicateAttribute');
 });
@@ -1451,6 +1451,56 @@ test('getReportExtracts with onlyLatest returns only the latest report for each
   assert.equal(mixReports[0]!.timeStamp, '260202T0000');
 });
 
+test('getReportExtracts reflects reports added, modified, and removed after a previous call', async () => {
+  const os = await import('node:os');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'kilotest-extracts-'));
+  const tmpReportsDir = path.join(tmpRoot, 'db', 'reports');
+  const savedDbDir = process.env.DB_DIR;
+  const sourcePath = path.join(reportsPath(), '260101T0000-mix.json');
+  process.env.DB_DIR = path.join(tmpRoot, 'db');
+  try {
+    await fs.mkdir(tmpReportsDir, {recursive: true});
+    const report = JSON.parse(await fs.readFile(sourcePath, 'utf8'));
+    const firstPath = path.join(tmpReportsDir, '260101T0000-aaa.json');
+    await fs.writeFile(firstPath, JSON.stringify(report));
+    let extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Mixed Outcomes Page']);
+    // Modify the report and give it a later modification time, as reannotation would.
+    report.target.what = 'Revised Page';
+    await fs.writeFile(firstPath, JSON.stringify(report));
+    const later = new Date(Date.now() + 60000);
+    await fs.utimes(firstPath, later, later);
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Revised Page']);
+    // Add a report.
+    report.target.what = 'Added Page';
+    const secondPath = path.join(tmpReportsDir, '260101T0001-bbb.json');
+    await fs.writeFile(secondPath, JSON.stringify(report));
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page', 'Revised Page']);
+    // Mutating a returned extract does not affect later results.
+    extracts[0]!.superseded = true;
+    extracts = await getReportExtracts();
+    assert.equal(extracts[0]!.superseded, undefined);
+    // Make a cached report unreadable.
+    await fs.writeFile(secondPath, 'not JSON');
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Revised Page']);
+    // Restore it.
+    await fs.writeFile(secondPath, JSON.stringify(report));
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page', 'Revised Page']);
+    // Remove a report, as hiding would.
+    await fs.rm(firstPath);
+    extracts = await getReportExtracts();
+    assert.deepEqual(extracts.map(e => e.description), ['Added Page']);
+  }
+  finally {
+    process.env.DB_DIR = savedDbDir;
+    await fs.rm(tmpRoot, {recursive: true}).catch(() => {});
+  }
+});
+
 test('getExclusionCookieValue is deterministic for a given AUTH_CODE', async () => {
   const savedAuthCode = process.env.AUTH_CODE;
   process.env.AUTH_CODE = 'test-auth-code';

package/util.ts

@@ -793,20 +793,58 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
     };
   }
 };
+// Cache of report extracts, keyed by report file path. Each entry records the modification
+// time and size of the file when it was extracted, so an entry is reused only while the file
+// is unchanged. Reports are mutable (e.g., reannotation rewrites all of them) and may be
+// written, hidden, or deleted by any process, so the cache is validated against the files
+// before every use rather than invalidated by the code that changes them.
+const reportExtractCache = new Map<string, {mtimeMs: number, size: number, extract: ReportExtract}>();
 // Returns extracts of all available reports.
 export const getReportExtracts = async (onlyLatest: boolean = false): Promise<ReportExtract[]> => {
-  // Get the names of the available report files.
-  const reportFileNames = await readdirOrCreate(reportsPath(), 'Reports directory');
+  const reportsDir = reportsPath();
+  // Get the names and paths of the available report files.
+  const reportFileNames = await readdirOrCreate(reportsDir, 'Reports directory');
+  const reportFilePaths = reportFileNames.map(fileName => path.join(reportsDir, fileName));
+  const reportFilePathSet = new Set(reportFilePaths);
+  // Remove from the cache any report that is no longer available (e.g., hidden or deleted).
+  for (const cachedPath of reportExtractCache.keys()) {
+    if (!reportFilePathSet.has(cachedPath)) {
+      reportExtractCache.delete(cachedPath);
+    }
+  }
+  // Get the current modification times and sizes of the report files. A file that disappeared
+  // after the directory was read gets values that match no cache entry, so it is reread, which
+  // fails and removes it from the cache.
+  const reportStats = await Promise.all(
+    reportFilePaths.map(filePath => fs.stat(filePath).catch(() => ({mtimeMs: NaN, size: NaN})))
+  );
   // Initialize an array of extracts.
   const extracts: ReportExtract[] = [];
-  // For each one:
-  for (const reportFileName of reportFileNames) {
+  // For each report file:
+  for (const [index, reportFileName] of reportFileNames.entries()) {
+    const filePath = reportFilePaths[index]!;
+    const stat = reportStats[index]!;
+    const cached = reportExtractCache.get(filePath);
+    // If its cached extract is current:
+    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+      // Add a copy of the cached extract to the array.
+      extracts.push({...cached.extract});
+      continue;
+    }
+    // Otherwise, get a new extract of it. The stat precedes the read, so a change between
+    // them leaves a stale modification time in the cache and causes a reread next time.
     const [timeStamp, jobID] = reportFileName.slice(0, -5).split('-') as [string, string];
-    // Get an extract of it.
     const extract = await getReportExtract(timeStamp, jobID);
+    // If this succeeded:
     if (!('error' in extract)) {
-      // Add the extract to the array.
-      extracts.push(extract);
+      // Cache it and add a copy of it to the array.
+      reportExtractCache.set(filePath, {mtimeMs: stat.mtimeMs, size: stat.size, extract});
+      extracts.push({...extract});
+    }
+    // Otherwise, i.e. if it failed:
+    else {
+      // Forget any outdated extract of it.
+      reportExtractCache.delete(filePath);
     }
   }
   // Sort the extracts by page description and, secondarily, completion time.

package/web/listReports/index.ts

@@ -97,7 +97,7 @@ const populateQuery = async (query: Record<string, any>) => {
   query.some = (reportCount || jobFileNames.queue.length || jobFileNames.claimed.length)
   ? 'another'
   : 'a';
-  const multiReportWhats = await getMultiReportWhats();
+  const multiReportWhats = await getMultiReportWhats(reportExtracts);
   // Sort them primarily by page description and secondarily by completion time.
   let sortedExtracts = objectSort(reportExtracts, 'reportTime', 'alpha');
   sortedExtracts = objectSort(sortedExtracts, 'description', 'alpha');

package/web/util.test.ts

@@ -293,6 +293,16 @@ test('getMultiReportWhats returns descriptions that have multiple reports', asyn
   assert.ok(whats.includes('Mixed Outcomes Page'));
 });
 
+test('getMultiReportWhats uses extracts provided by the caller', async () => {
+  const extract = {timeStamp: 't', jobID: 'j', url: 'https://example.com/', reportTime: ''};
+  const whats = await getMultiReportWhats([
+    {...extract, description: 'B'},
+    {...extract, description: 'A'},
+    {...extract, description: 'B'}
+  ]);
+  assert.deepEqual(whats, ['B']);
+});
+
 // Returns a minimal report for testing rule-engine identification.
 const makeEngineReport = (whiches: string[], preventions: Record<string, string>) => ({
   acts: whiches.map(which => ({type: 'test', which})),

package/web/util.ts

@@ -21,7 +21,7 @@ import {
 } from '../util.ts';
 import {issues as issueSpecs} from 'testaro-issues';
 import type {Catalog} from 'testaro';
-import type {UsableReport} from '../util.ts';
+import type {ReportExtract, UsableReport} from '../util.ts';
 /* c8 ignore stop */
 import wcagMap from '../wcagMap.json' with {type: 'json'};
 
@@ -372,9 +372,11 @@ export const getViolatorFactsLines = (
   lines.push(`${margin}</ul>`);
   return lines;
 };
-// Gets the descriptions of multi-report pages.
-export const getMultiReportWhats = async (): Promise<string[]> => {
-  const reportExtracts = await getReportExtracts();
+// Gets the descriptions of multi-report pages, from extracts already obtained, if provided.
+export const getMultiReportWhats = async (
+  reportExtracts?: ReportExtract[]
+): Promise<string[]> => {
+  reportExtracts ??= await getReportExtracts();
   const sortedDescriptions = reportExtracts.map(extract => extract.description).sort();
   const multiReportDescriptions = sortedDescriptions.filter(
     (description, index) => description !== sortedDescriptions[index - 1] && description === sortedDescriptions[index + 1]