@jrpool/kilotest 58.2.4 → 59.0.2

package/web/listPages/index.ts

@@ -0,0 +1,99 @@
+/*
+  index.ts
+  Lists all tested pages, with links to the latest reports about them.
+*/
+
+// IMPORTS
+
+import {
+  getJobNames,
+  getObject,
+  getReportExtracts,
+  getTestRequests,
+  jobsPath,
+  populateTemplate
+} from '../../util.ts';
+import path from 'node:path';
+
+// FUNCTIONS
+
+// Adds parameters to a query for the answer page.
+const populateQuery = async (query: Record<string, any>) => {
+  const margin = ' '.repeat(8);
+  // Initialize the classes of lines.
+  const lines: {requests: string[], queue: string[], claimed: string[], tested: string[]} = {
+    requests: [],
+    queue: [],
+    claimed: [],
+    tested: []
+  };
+  // Get the test requests.
+  const testRequests = await getTestRequests();
+  // For each requested URL:
+  Object.keys(testRequests).forEach(url => {
+    // For each of its requests:
+    testRequests[url]!.forEach((req: any) => {
+      const {description, reason} = req;
+      // Add a line.
+      lines.requests.push(`${margin}<li><code>${url}</code> (${description}): ${reason}</li>`);
+    });
+  });
+  // Sort the lines in alphabetical order by URL and secondarily by proposed name.
+  lines.requests.sort();
+  // Add the lines to the query.
+  query.requests = lines.requests.join('\n');
+  // Add a no-requests message, if applicable, to the query.
+  query.noRequests = lines.requests.length
+  ? 'Kilotest managers can <a href="enqueueForm.html">approve or reject a request</a>.'
+  : 'No requests await approval now.';
+  // Get the file names of all queued and claimed jobs.
+  const jobFileNames = await getJobNames();
+  // For each job category:
+  for (const category of ['queue', 'claimed'] as const) {
+    // For each job in the category:
+    for (const fileName of jobFileNames[category]) {
+      // Get the job.
+      const job = await getObject(path.join(jobsPath(), category, fileName)) as {target: {url: string, what: string}};
+      // Add a line.
+      lines[category].push(`${margin}<li><code>${job.target.url}</code> (${job.target.what})</li>`);
+    }
+    // Add the lines to the query.
+    query[category] = lines[category].join('\n');
+  }
+  // Add a no-queued message, if applicable, to the query.
+  query.noQueued = lines.queue.length ? '' : 'No pages are queued for testing.';
+  // Add a no-claimed message, if applicable, to the query.
+  query.noClaimed = lines.claimed.length ? '' : 'No pages are being tested now.';
+  // Get extracts of the latest reports about all tested pages, sorted by page description.
+  const latestExtracts = await getReportExtracts(true);
+  const pageCount = latestExtracts.length;
+  // For each tested page:
+  for (const extract of latestExtracts) {
+    const {jobID, timeStamp, description} = extract;
+    // Add a link to the issues in the latest report about it to the lines.
+    const link = `<a href="listIssues.html/${timeStamp}/${jobID}" aria-label="Get test results for ${description}">${description}</a>`;
+    lines.tested.push(`${margin}  <li>${link}</li>`);
+  }
+  // Add the lines to the query, as an introduced list if there are any, or else a no-pages message.
+  query.testedPages = pageCount
+  ? [
+    `${margin}<p>Get test results for:</p>`,
+    `${margin}<ul class="links">`,
+    ...lines.tested,
+    `${margin}</ul>`
+  ].join('\n')
+  : `${margin}<p>No pages have been tested yet.</p>`;
+};
+// Returns a page listing the tested pages.
+export const answer = async () => {
+  const query: Record<string, any> = {};
+  // Create a query to replace placeholders.
+  await populateQuery(query);
+  // Get the populated template.
+  const answerPage = await populateTemplate(import.meta.dirname, query);
+  // Return the populated page.
+  return {
+    status: 'ok',
+    answerPage
+  };
+};

package/web/listPages/listPages.test.ts

@@ -0,0 +1,196 @@
+/*
+  listPages.test.ts
+  UI tests for web/listPages/index.ts using the fixture corpus.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import {parse} from 'node-html-parser';
+import {answer} from './index.ts';
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(async () => {
+  process.env.DB_DIR = (await import('../../test/dbFixture.ts')).fixtureDBDir;
+  // Ensure job subdirectories exist (they are empty and not tracked by Git).
+  for (const sub of ['queue', 'claimed', 'failed']) {
+    await fs.mkdir(path.join(process.env.DB_DIR, 'jobs', sub), {recursive: true});
+  }
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('listPages returns an ok status with valid HTML', async () => {
+  const result: any = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  const html = parse(result.answerPage);
+  assert.equal(html.querySelector('title')?.text, 'Pages tested | Kilotest');
+});
+
+// Returns the links in the list of tested pages.
+const getPageLinks = (answerPage: string) => {
+  const html = parse(answerPage);
+  return html.querySelectorAll('main > ul > li > a');
+};
+
+test('listPages lists each of the 7 tested pages once, by description', async () => {
+  const result: any = await answer();
+  const links = getPageLinks(result.answerPage);
+  assert.deepEqual(
+    links.map(a => a.text),
+    [
+      'All CantTell Page',
+      'Branch Coverage Page',
+      'Empty Results Page',
+      'Mixed Outcomes',
+      'Multi Violator Page',
+      'No Outcomes Page',
+      'Prevented Page'
+    ]
+  );
+});
+
+test('listPages introduces the list of tested pages', async () => {
+  const result: any = await answer();
+  assert.ok(result.answerPage.includes('<p>Get test results for:</p>'));
+  assert.ok(!result.answerPage.includes('No pages have been tested yet.'));
+});
+
+test('listPages links each page to the issues in its latest report', async () => {
+  const result: any = await answer();
+  const links = getPageLinks(result.answerPage);
+  const mixedLink = links.find(a => a.text === 'Mixed Outcomes');
+  assert.equal(mixedLink?.getAttribute('href'), 'listIssues.html/260202T0000/new');
+  const canttellLink = links.find(a => a.text === 'All CantTell Page');
+  assert.equal(canttellLink?.getAttribute('href'), 'listIssues.html/260101T0001/ct');
+});
+
+test('listPages contains no report summaries', async () => {
+  const result: any = await answer();
+  const html = parse(result.answerPage);
+  assert.equal(html.querySelectorAll('details').length, 0);
+  assert.ok(!result.answerPage.includes('https://example.com/mixed'));
+});
+
+test('listPages does not include the hidden report', async () => {
+  const result: any = await answer();
+  assert.ok(!result.answerPage.includes('Hidden Page'));
+});
+
+test('listPages includes a link to request testing a new page', async () => {
+  const result: any = await answer();
+  const html = parse(result.answerPage);
+  const testLink = html.querySelector('a[href="requestNewTestForm.html"]');
+  assert.ok(testLink);
+});
+
+test('listPages shows requests when testRequests.json has entries', {timeout: 500}, async () => {
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
+  const testRequestsPath = path.join(dbDir, 'jobs', 'testRequests.json');
+  const originalTestRequests = await fs.readFile(testRequestsPath, 'utf8');
+  try {
+    const testRequests = {
+      'https://example.com/mixed': [
+        {description: 'Mixed Outcomes', reason: 'Needs retesting for accessibility'}
+      ]
+    };
+    await fs.writeFile(testRequestsPath, JSON.stringify(testRequests, null, 2));
+    const result: any = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('https://example.com/mixed'));
+    assert.ok(result.answerPage.includes('Needs retesting for accessibility'));
+  }
+  finally {
+    await fs.writeFile(testRequestsPath, originalTestRequests);
+  }
+});
+
+test('listPages shows queued and claimed jobs when they exist', async () => {
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
+  const queueDir = path.join(dbDir, 'jobs', 'queue');
+  const claimedDir = path.join(dbDir, 'jobs', 'claimed');
+  const queueFile = path.join(queueDir, 'queuedJob.json');
+  const claimedFile = path.join(claimedDir, 'claimedJob.json');
+  try {
+    const queuedJob = {
+      target: {url: 'https://example.com/queued', what: 'Queued Page'}
+    };
+    const claimedJob = {
+      target: {url: 'https://example.com/claimed', what: 'Claimed Page'}
+    };
+    await fs.writeFile(queueFile, JSON.stringify(queuedJob, null, 2));
+    await fs.writeFile(claimedFile, JSON.stringify(claimedJob, null, 2));
+    const result: any = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('https://example.com/queued'));
+    assert.ok(result.answerPage.includes('Queued Page'));
+    assert.ok(result.answerPage.includes('https://example.com/claimed'));
+    assert.ok(result.answerPage.includes('Claimed Page'));
+  }
+  finally {
+    await fs.unlink(queueFile).catch(() => {});
+    await fs.unlink(claimedFile).catch(() => {});
+  }
+});
+
+test('listPages lists a page whose report is not usable', {timeout: 500}, async () => {
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
+  const reportsDir = path.join(dbDir, 'reports');
+  const invalidReportPath = path.join(reportsDir, '260101T9999-bad.json');
+  try {
+    // Valid for getReportExtract (has target and jobData.endTime) but not usable by isUsableReport (no acts or catalog).
+    const invalidReport = {
+      target: {what: 'Invalid Report', url: 'https://example.com/invalid'},
+      jobData: {endTime: '26-01-01T00:10'}
+    };
+    await fs.writeFile(invalidReportPath, JSON.stringify(invalidReport, null, 2));
+    const result: any = await answer();
+    assert.equal(result.status, 'ok');
+    const links = getPageLinks(result.answerPage);
+    assert.ok(links.some(a => a.text === 'Invalid Report'));
+  }
+  finally {
+    await fs.unlink(invalidReportPath).catch(() => {});
+  }
+});
+
+test('listPages shows no-reports message when the database is empty', async () => {
+  // Create a temp DB with empty reports and jobs directories.
+  const os = await import('node:os');
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'listpages-empty-'));
+  await fs.mkdir(path.join(tmpDir, 'reports'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'queue'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'claimed'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'failed'), {recursive: true});
+  await fs.writeFile(path.join(tmpDir, 'jobs', 'testRequests.json'), '{}\n');
+  const savedDBDir = process.env.DB_DIR;
+  process.env.DB_DIR = tmpDir;
+  try {
+    const {answer} = await import('./index.ts');
+    const result: any = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('<p>No pages have been tested yet.</p>'));
+    assert.ok(!result.answerPage.includes('Get test results for:'));
+    assert.equal(getPageLinks(result.answerPage).length, 0);
+  }
+  finally {
+    process.env.DB_DIR = savedDBDir;
+    await fs.rm(tmpDir, {recursive: true}).catch(() => {});
+  }
+});

package/web/listViolators/listViolators.test.ts

@@ -188,7 +188,7 @@ test('listViolators includes take-me-there links for text-linkable violators', a
 
 test('listViolators returns an error when report facts are not obtained', async () => {
   pageDataStringsOverride = {
-    what: 'Mixed Outcomes Page',
+    what: 'Mixed Outcomes',
     url: 'https://example.com/mixed',
     urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
   };

package/web/metrics/metrics.test.ts

@@ -103,7 +103,7 @@ test('metrics reports recorded counts with a valid auth code on a POST request',
   await fs.writeFile(metricsPath(), getJSON({
     since: '260101T0000',
     pageViews: {tutorialWeb: 3},
-    mcpToolCalls: {listReports: 5},
+    mcpToolCalls: {listPages: 5},
     apiOperations: {},
     managerActivity: {}
   }));
@@ -177,7 +177,7 @@ test('metrics clears all counts and shows a confirmation when clearCounts is sub
   await fs.writeFile(metricsPath(), getJSON({
     since: '260101T0000',
     pageViews: {tutorialWeb: 9},
-    mcpToolCalls: {listReports: 3},
+    mcpToolCalls: {listPages: 3},
     apiOperations: {getReport: 1},
     managerActivity: {reannotate: {ok: 1, error: 2}}
   }));

package/web/requestNewTest/requestNewTest.test.ts

@@ -123,7 +123,7 @@ test('answer returns an error when a report already exists for the page', {timeo
   const {answer} = await import('./index.ts');
   // The fixture database already has a report for this description and URL.
   const result: any = await answer(
-    'Mixed Outcomes Page', 'https://example.com/mixed', 'Because accessibility'
+    'Mixed Outcomes', 'https://example.com/mixed', 'Because accessibility'
   );
   assert.equal(result.status, 'error');
   assert.equal(result.message, 'A report about a page with the same description or URL is already available');

package/web/requestRetest/requestRetest.test.ts

@@ -102,7 +102,7 @@ test('answer returns an error for a duplicate retest request', async () => {
 
 test('answer returns an error when the cited report has been superseded', async () => {
   const {answer} = await import('./index.ts');
-  // 260101T0000-mix (Mixed Outcomes Page) is superseded by 260202T0000-new.
+  // 260101T0000-mix (Mixed Outcomes) is superseded by 260202T0000-new.
   const result: any = await answer('260101T0000/mix', 'Because changes were made');
   assert.equal(result.status, 'error');
   assert.equal(result.message, 'A later report about the page is already available');
@@ -141,4 +141,3 @@ test('answer returns an error with a fallback channel when the request queue is
   assert.ok(result.message.includes('https://github.com/jrpool/kilotest/issues'));
   assert.ok(result.message.includes('info@kilotest.com'));
 });
-

package/web/requestRetestForm/index.ts

@@ -31,12 +31,14 @@ export const answer = async (pageArgs: string) => {
     // Make the form report the failure.
     target = 'The specified page is not available for retesting';
   }
+  // Get the completion time of the report, or an invalid time if the report is unavailable.
+  const reportTime = new Date(reportExtract?.reportTime ?? NaN);
   const query: Record<string, string> = {
     target,
     timeStamp,
     jobID,
-    ago: getAgoString(timeStamp),
-    dateTime: getDateTimeString(timeStamp)
+    ago: getAgoString(reportTime),
+    dateTime: getDateTimeString(reportTime)
   };
   // Get the recommendation form template.
   const answerPage = await populateTemplate(import.meta.dirname, query);

package/web/requestRetestForm/requestRetestForm.test.ts

@@ -35,7 +35,7 @@ test('requestRetestForm returns ok with the page name for a valid report', async
   assert.ok(result.answerPage);
   const html = parse(result.answerPage);
   const title = html.querySelector('title')?.text;
-  assert.ok(title?.includes('Mixed Outcomes Page'));
+  assert.ok(title?.includes('Mixed Outcomes'));
 });
 
 test('requestRetestForm populates the form action with the timeStamp and jobID', async () => {
@@ -51,6 +51,17 @@ test('requestRetestForm shows the fallback message for a nonexistent report', as
   assert.ok(result.answerPage.includes('The specified page is not available for retesting'));
 });
 
+test('requestRetestForm dates the report by its completion time', async () => {
+  const result = await answer('260202T0000/new');
+  assert.ok(result.answerPage.includes('on 2026-02-02 at 00:10'));
+});
+
+test('requestRetestForm describes the time of a nonexistent report as unknown', async () => {
+  const result = await answer('999999T9999/nope');
+  assert.ok(result.answerPage.includes('an unknown number of days ago'));
+  assert.ok(result.answerPage.includes('on an unknown date at an unknown time'));
+});
+
 test('requestRetestForm includes the ago and dateTime placeholders replaced', async () => {
   const result = await answer('260202T0000/new');
   assert.ok(!result.answerPage.includes('__ago__'));

package/web/unhideReportForm/index.ts

@@ -6,8 +6,9 @@
 // IMPORTS
 
 import {
-  hiddenReportsPath, isValidAuthCode, populateTemplate, readdirOrCreate, reportsPath
+  getReportEndTime, hiddenReportsPath, isValidAuthCode, populateTemplate, readdirOrCreate, reportsPath
 } from '../../util.ts';
+import {getDateTimeString} from '../util.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -64,13 +65,14 @@ export const answer = async (_: any, search: string, method: string) => {
     reportsData.push({
       description,
       timeStamp,
-      jobID
+      jobID,
+      reportTime: getReportEndTime(report)
     });
   }
-  // Sort the data by page name and then by time stamp.
+  // Sort the data by page name and then by completion time.
   reportsData.sort((a, b) => {
     if (a.description === b.description) {
-      return a.timeStamp.localeCompare(b.timeStamp);
+      return a.reportTime.getTime() - b.reportTime.getTime();
     }
     return a.description.localeCompare(b.description, 'en', {sensitivity: 'base'});
   });
@@ -78,8 +80,9 @@ export const answer = async (_: any, search: string, method: string) => {
   const margin = ' '.repeat(12);
   // For each report:
   reportsData.forEach(data => {
-    const {jobID, timeStamp, description} = data;
-    const specString = `${description} (job <code>${jobID}</code> at ${timeStamp})`;
+    const {jobID, timeStamp, description, reportTime} = data;
+    const when = getDateTimeString(reportTime);
+    const specString = `${description} (job <code>${timeStamp}-${jobID}</code> completed ${when})`;
     // Add a line with a radio button to unhide it.
     lines.push(
       `${margin}<p><input type="radio" name="report" value="${timeStamp}-${jobID}"> ${specString}</p>`

package/web/unhideReportForm/unhideReportForm.test.ts

@@ -100,21 +100,24 @@ test('unhideReportForm returns an error when unhiding a nonexistent report on a
   assert.ok(result.message.includes('Unhiding report'));
 });
 
-test('unhideReportForm sorts hidden reports with the same page name by timeStamp', async () => {
+test('unhideReportForm sorts hidden reports with the same page name by completion time', async () => {
   const {hidden} = getPaths();
   // Add a second hidden report with the same what as the existing one.
   const existing = JSON.parse(await fs.readFile(hidden, 'utf8'));
-  // Create a copy with a different timeStamp but same target.what.
+  // Create a copy with a later job time stamp but an earlier completion time.
   const copy = JSON.parse(JSON.stringify(existing));
   copy.id = '260101T0010-hid2';
+  copy.jobData.endTime = '26-01-01T00:05';
   const copyPath = path.join(hiddenReportsPath(), '260101T0010-hid2.json');
   await fs.writeFile(copyPath, JSON.stringify(copy));
   try {
     const result: any = await answer(null, '', 'GET');
     assert.equal(result.status, 'ok');
-    // Both reports should appear in the form.
-    assert.ok(result.answerPage.includes('260101T0007-hid'));
-    assert.ok(result.answerPage.includes('260101T0010-hid2'));
+    // Both reports should appear in the form, in order of completion time.
+    const page: string = result.answerPage;
+    assert.ok(page.includes('(job <code>260101T0007-hid</code> completed 2026-01-01 at 00:10)'));
+    assert.ok(page.includes('(job <code>260101T0010-hid2</code> completed 2026-01-01 at 00:05)'));
+    assert.ok(page.indexOf('260101T0010-hid2') < page.indexOf('260101T0007-hid'));
   }
   finally {
     await fs.unlink(copyPath).catch(() => {});

package/web/util.test.ts

@@ -9,14 +9,15 @@ import {test, before, after} from 'node:test';
 import assert from 'node:assert/strict';
 import path from 'node:path';
 import fs from 'node:fs/promises';
+import {parse} from 'node-html-parser';
 import {getReport, isReportError, reportsPath} from '../util.ts';
 import {
   checkCommentLength,
   getAgoString,
   getCountString,
+  getDateTimeString,
   getEngineIDs,
   getEngineNamesString,
-  getMultiReportWhats,
   getPageData,
   getPageDataStrings,
   getPageFactsLines,
@@ -114,7 +115,7 @@ test('getWeightName returns the correct name for each weight', () => {
 });
 
 test('makeBreakable inserts wbr before non-initial slashes', () => {
-  assert.equal(makeBreakable('/api/listReports'), '/api<wbr>/listReports');
+  assert.equal(makeBreakable('/api/listPages'), '/api<wbr>/listPages');
 });
 
 // Returns a fixture report, failing the test if it is not usable.
@@ -128,7 +129,7 @@ const getFixtureReport = async (timeStamp: string, jobID: string) => {
 
 test('getPageData returns page data for a valid report', async () => {
   const data = getPageData(await getFixtureReport('260101T0000', 'mix'));
-  assert.equal(data.description, 'Mixed Outcomes Page');
+  assert.equal(data.description, 'Mixed Outcomes');
   assert.equal(data.url, 'https://example.com/mixed');
   assert.equal(typeof data.daysAgo, 'number');
 });
@@ -140,18 +141,29 @@ test('getReport returns an error for a nonexistent report', async () => {
 
 test('getPageDataStrings returns HTML strings for a valid report', async () => {
   const strings = getPageDataStrings(await getFixtureReport('260101T0000', 'mix'));
-  assert.equal(strings.description, 'Mixed Outcomes Page');
+  assert.equal(strings.description, 'Mixed Outcomes');
   assert.equal(strings.url, 'https://example.com/mixed');
   assert.equal(strings.urlLink, '<a href="https://example.com/mixed">https://example.com/mixed</a>');
   assert.ok(strings.testInfo.includes('by job <code>260101T0000-mix</code>'));
-  assert.ok(strings.testInfo.includes('2026-01-01 at 00:00'));
+  assert.ok(strings.testInfo.includes('2026-01-01 at 00:10'));
 });
 
-test('getPageDataStrings returns different testInfo for a different timeStamp', async () => {
-  const strings = getPageDataStrings(await getFixtureReport('260101T0001', 'ct'));
+test('getPageDataStrings dates a report by its completion time, not by its job time stamp', async () => {
+  const report = await getFixtureReport('260101T0001', 'ct');
+  report.jobData.endTime = '26-03-04T05:06';
+  const strings = getPageDataStrings(report);
   assert.equal(strings.description, 'All CantTell Page');
   assert.ok(strings.testInfo.includes('by job <code>260101T0001-ct</code>'));
-  assert.ok(strings.testInfo.includes('2026-01-01 at 00:01'));
+  assert.ok(strings.testInfo.includes('2026-03-04 at 05:06'));
+  assert.ok(!strings.testInfo.includes('2026-01-01'));
+});
+
+test('getDateTimeString describes a date', () => {
+  assert.equal(getDateTimeString(new Date('2026-03-04T05:06:07Z')), '2026-03-04 at 05:06');
+});
+
+test('getDateTimeString describes an invalid date as unknown', () => {
+  assert.equal(getDateTimeString(new Date(NaN)), 'an unknown date at an unknown time');
 });
 
 test('getPageDataStrings derives the strings from the report object', async () => {
@@ -209,6 +221,73 @@ test('getPageFactsLines returns the about-page list lines for a report', async (
   assert.ok(html.includes('<li>Issues: 2</li>'));
 });
 
+test('getPageFactsLines ends with a link to download the full report', async () => {
+  const {getReportData} = await import('./util.ts');
+  const report = await getFixtureReport('260101T0000', 'mix');
+  const lines = getPageFactsLines(getPageDataStrings(report), getReportData(report), '');
+  const topItems = parse(lines.join('\n')).querySelectorAll('ul:not(ul ul) > li');
+  const lastItem = topItems[topItems.length - 1]!;
+  assert.ok(topItems[topItems.length - 2]!.text.trim().startsWith('Summary of results:'));
+  assert.equal(lastItem.querySelector('a')?.getAttribute('href'), '/fullReport.json/260101T0000/mix');
+  assert.equal(lastItem.text.trim(), 'Download the full technical report (JSON)');
+});
+
+// Returns the 3 rule-engine amounts and the 3 summary amounts of the page facts of a report.
+const getResultFacts = async (timeStamp: string, jobID: string) => {
+  const {getReportData} = await import('./util.ts');
+  const report = await getFixtureReport(timeStamp, jobID);
+  const lines = getPageFactsLines(getPageDataStrings(report), getReportData(report), '');
+  const items = parse(lines.join('\n')).querySelectorAll('li');
+  const itemTexts: string[] = items.map(li => li.text.trim());
+  const getAmount = (label: string) => {
+    const text = itemTexts.find(t => t.startsWith(`${label}: `));
+    assert.ok(text, `${label} item exists`);
+    return Number(text.slice(label.length + 2));
+  };
+  // The summary item is the parent of the rule-engine item and the 3 amount items.
+  const summaryItem = items.find(li => li.text.trim().startsWith('Summary of results:'));
+  assert.ok(summaryItem, 'Summary of results item exists');
+  const summaryList = summaryItem.querySelector('ul')!;
+  const amountLabels = summaryList.childNodes
+  .filter((node: any) => node.tagName === 'LI')
+  .map(li => li.text.trim().split(':')[0]);
+  return {
+    called: getAmount('Called'),
+    tested: getAmount('Were able to test'),
+    reporters: getAmount('Reported any rule violations'),
+    amountLabels,
+    violations: getAmount('Violations'),
+    violators: getAmount('Violators'),
+    issues: getAmount('Issues')
+  };
+};
+
+// Expected facts, hand-computed from the fixtures.
+const expectedFacts: [string, string, number, number, number, number, number, number][] = [
+  // Time stamp, job ID, engines called, engines able to test, reporting engines, violations, violators, issues.
+  ['260101T0000', 'mix', 2, 2, 2, 3, 2, 2],
+  ['260202T0000', 'new', 1, 1, 1, 1, 1, 1],
+  ['260101T0001', 'ct', 1, 1, 0, 0, 0, 0],
+  ['260101T0002', 'no', 1, 1, 1, 1, 1, 1],
+  ['260101T0005', 'emp', 1, 1, 0, 0, 0, 0],
+  ['260101T0006', 'prv', 2, 1, 1, 1, 1, 1],
+  ['260101T0008', 'mul', 2, 2, 2, 4, 3, 1],
+  ['260101T0009', 'brd', 3, 3, 1, 4, 4, 1]
+];
+
+for (const [timeStamp, jobID, called, tested, reporters, violations, violators, issues] of expectedFacts) {
+  test(`getPageFactsLines gives correct rule-engine and summary amounts for ${timeStamp}-${jobID}`, async () => {
+    const facts = await getResultFacts(timeStamp, jobID);
+    assert.equal(facts.called, called);
+    assert.equal(facts.tested, tested);
+    assert.equal(facts.reporters, reporters);
+    assert.deepEqual(facts.amountLabels, ['Rule engines', 'Violations', 'Violators', 'Issues']);
+    assert.equal(facts.violations, violations);
+    assert.equal(facts.violators, violators);
+    assert.equal(facts.issues, issues);
+  });
+}
+
 test('getIssueFactsLines returns the about-issue list lines for a report', async () => {
   const {getIssueFactsLines} = await import('./util.ts');
   const report = await getFixtureReport('260101T0000', 'mix');
@@ -288,21 +367,6 @@ test('getEngineNamesString falls back to the ID for an unknown engine', () => {
   assert.equal(getEngineNamesString(new Set(['unknownEngine'])), 'unknownEngine');
 });
 
-test('getMultiReportWhats returns descriptions that have multiple reports', async () => {
-  const whats = await getMultiReportWhats();
-  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})),