@jrpool/kilotest 58.2.4 → 59.0.0

package/util.ts

@@ -689,7 +689,7 @@ export const isUsableReport = (report: unknown): report is UsableReport => {
   )
   && typeof r.jobData === 'object'
   && r.jobData.endTime
-  && !isNaN(new Date(`20${r.jobData.endTime}Z`).getTime())
+  && !isNaN(getReportEndTime(r).getTime())
   && typeof r.catalog === 'object';
 };
 // Returns a report.
@@ -754,7 +754,7 @@ export const annotateReportObject = async (report: UsableReport): Promise<void>
     );
   }
 };
-// Returns the creation time and size of a report.
+// Returns the size of a report, or null if the report does not exist.
 export const getReportStats = async (timeStamp: string, jobID: string) => {
   let reportStat;
   try {
@@ -763,10 +763,15 @@ export const getReportStats = async (timeStamp: string, jobID: string) => {
   catch {
     return null;
   }
-  const reportTime = reportStat.birthtime;
   const reportSize = reportStat.size;
-  return {reportTime, reportSize};
+  return {reportSize};
 };
+// Returns the completion time of a report. This, not the time stamp in the job ID nor the
+// file system time of the report file, is the time of a report. The date is invalid if the
+// report has no valid completion time.
+export const getReportEndTime = (report: {jobData?: {endTime?: string}}): Date => new Date(
+  `20${report.jobData?.endTime}Z`
+);
 
 // Returns an extract of an available report, or an error object if it cannot be read or parsed.
 export const getReportExtract = async (timeStamp: string, jobID: string): Promise<ReportExtract | {error: string}> => {
@@ -784,7 +789,7 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
       jobID,
       description,
       url,
-      reportTime: new Date(`20${jobData.endTime}Z`).toISOString()
+      reportTime: getReportEndTime({jobData}).toISOString()
     };
   }
   catch {
@@ -861,6 +866,12 @@ export const getReportExtracts = async (onlyLatest: boolean = false): Promise<Re
   // Return the array, excluding extracts of superseded reports if so specified.
   return onlyLatest ? extracts.filter(extract => !extract.superseded) : extracts;
 };
+// Returns extracts of all available reports about the page with a description, from oldest
+// to latest.
+export const getPageReportExtracts = async (description: string): Promise<ReportExtract[]> => {
+  const reportExtracts = await getReportExtracts();
+  return reportExtracts.filter(extract => extract.description === description);
+};
 // Returns whether a report with a description or URL is available.
 export const isReportAvailable = async (description: string, url: string): Promise<boolean> => {
   const reportExtracts = await getReportExtracts();

package/web/enqueueForm/index.html

@@ -14,7 +14,7 @@
     <main>
       <h1><a href="/">Kilotest</a>: Request approval or rejection</h1>
       <p>To approve a test or retest request, check its requested page name.</p>
-      <p>To approve testing a page that has not yet been requested, first <a href="listReports.html">request it</a>.</p>
+      <p>To approve testing a page that has not yet been requested, first <a href="listPages.html">request it</a>.</p>
       <p>To reject all requests for a page, check the radio button of its URL.</p>
       <form action="/requestAction.html" method="post">
         <fieldset>

package/web/hideReportForm/hideReportForm.test.ts

@@ -53,6 +53,11 @@ test('hideReportForm displays a list of reports on a GET request', async () => {
   assert.ok(radios.length > 0);
 });
 
+test('hideReportForm describes each report by its completion time', async () => {
+  const result: any = await answer(null, '', 'GET');
+  assert.ok(result.answerPage.includes('(job <code>260202T0000-new</code> completed 2026-02-02 at 00:10)'));
+});
+
 test('hideReportForm ignores a report query string on a GET request', async () => {
   const reportPath = path.join(reportsPath(), '260101T0009-brd.json');
   const hiddenPath = path.join(hiddenReportsPath(), '260101T0009-brd.json');

package/web/hideReportForm/index.ts

@@ -8,6 +8,7 @@
 import {
   getReportExtracts, hiddenReportsPath, isValidAuthCode, populateTemplate, reportsPath
 } from '../../util.ts';
+import {getDateTimeString} from '../util.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -54,18 +55,19 @@ export const answer = async (_: any, search: string, method: string) => {
   const reportExtracts = await getReportExtracts();
   // For each report:
   for (const reportExtract of reportExtracts) {
-    const {jobID, timeStamp, description} = reportExtract;
+    const {jobID, timeStamp, description, reportTime} = reportExtract;
     // Add the report to the array.
     reportSpecs.push({
       description,
       timeStamp,
-      jobID
+      jobID,
+      reportTime
     });
   }
-  // Sort the data by page name and then by time stamp.
+  // Sort the data by page name and then by completion time.
   reportSpecs.sort((a, b) => {
     if (a.description === b.description) {
-      return a.timeStamp.localeCompare(b.timeStamp);
+      return a.reportTime.localeCompare(b.reportTime);
     }
     return a.description.localeCompare(b.description);
   });
@@ -73,8 +75,9 @@ export const answer = async (_: any, search: string, method: string) => {
   const margin = ' '.repeat(12);
   // For each available report:
   reportSpecs.forEach(spec => {
-    const {jobID, timeStamp, description} = spec;
-    const specString = `${description} (job <code>${jobID}</code> at ${timeStamp})`;
+    const {jobID, timeStamp, description, reportTime} = spec;
+    const when = getDateTimeString(new Date(reportTime));
+    const specString = `${description} (job <code>${timeStamp}-${jobID}</code> completed ${when})`;
     // Add a line with a radio button to hide it.
     lines.push(
       `${margin}<p><input type="radio" name="report" value="${timeStamp}-${jobID}"> ${specString}</p>`

package/web/listIssues/index.html

@@ -25,7 +25,8 @@
         <blockquote>Kilotest reports defects on the __target__ web page. Summarize them and propose a plan to resolve the genuine ones.</blockquote>
       </details>
 __pageFacts__
-      <p><a href="/requestRetestForm.html/__timeStamp__/__jobID__">Should Kilotest retest the page?</a></p>
+      <h2>History</h2>
+__history__
       <h2>Issues reported</h2>
       <details>
         <summary>Highest priority: __highestCount__</summary>

package/web/listIssues/index.ts

@@ -6,6 +6,7 @@
 // IMPORTS
 
 import {
+  getPageReportExtracts,
   getReport,
   getTestActInstances,
   isReportError,
@@ -14,6 +15,7 @@ import {
 } from '../../util.ts';
 import type {UsableReport} from '../../util.ts';
 import {
+  getAgoString,
   getIssueFactsLines,
   getPageDataStrings,
   getPageFactsLines,
@@ -121,6 +123,47 @@ const getIssuesData = (report: UsableReport): ResultsSummary & Record<string, an
   // Return the data.
   return final;
 };
+// Returns the lines of the history of the reports about the page of a report.
+const getHistoryLines = async (
+  timeStamp: string, jobID: string, description: string, margin: string
+): Promise<string[]> => {
+  // Get extracts of all reports about the page, from oldest to latest.
+  const pageExtracts = await getPageReportExtracts(description);
+  const lastIndex = pageExtracts.length - 1;
+  // Initialize the list items and whether the report is the latest about the page.
+  const itemLines: string[] = [];
+  let isLatest = false;
+  // For each report about the page:
+  pageExtracts.forEach((extract, index) => {
+    const isThis = extract.timeStamp === timeStamp && extract.jobID === jobID;
+    isLatest ||= isThis && index === lastIndex;
+    // Get the tags that identify its position and whether it is this report.
+    const tags = [
+      index === 0 ? 'oldest' : '',
+      index === lastIndex ? 'latest' : '',
+      isThis ? 'this report' : ''
+    ]
+    .filter(tag => tag);
+    const tagString = tags.length ? ` (${tags.join('; ')})` : '';
+    const label = `${getAgoString(new Date(extract.reportTime))} ago${tagString}`;
+    // Add a list item describing it, linked unless it is this report, to the items.
+    const href = `/listIssues.html/${extract.timeStamp}/${extract.jobID}`;
+    const content = isThis ? label : `<a href="${href}">${label}</a>`;
+    itemLines.push(`${margin}  <li>${content}</li>`);
+  });
+  // Initialize the lines with a list of the reports, or a statement that there is only one.
+  const lines = itemLines.length > 1
+  ? [`${margin}<ol>`, ...itemLines, `${margin}</ol>`]
+  : [`${margin}<p>This is the only report about the page.</p>`];
+  // If the report is the latest about the page:
+  if (isLatest) {
+    // Add a link to the form for requesting a retest to the lines.
+    const href = `/requestRetestForm.html/${timeStamp}/${jobID}`;
+    lines.push(`${margin}<p><a href="${href}">Should Kilotest retest the page?</a></p>`);
+  }
+  // Return the lines.
+  return lines;
+};
 // Adds parameters to a query for the answer page.
 const populateQuery = async (timeStamp: string, jobID: string, query: Record<string, any>) => {
   // Get the report.
@@ -150,10 +193,9 @@ const populateQuery = async (timeStamp: string, jobID: string, query: Record<str
   const margin = ' '.repeat(6);
   // Add the page-facts list to the query.
   query.pageFacts = getPageFactsLines(pageInfo, issuesData, margin).join('\n');
+  // Add the history of reports about the page to the query.
+  query.history = (await getHistoryLines(timeStamp, jobID, description, margin)).join('\n');
   const {issues} = issuesData;
-  // Add report data to the query.
-  query.timeStamp = timeStamp;
-  query.jobID = jobID;
   // Add a summary of the issues to the query.
   query.highestCount = issues[4].length;
   query.highCount = issues[3].length;

package/web/listIssues/listIssues.test.ts

@@ -205,3 +205,79 @@ test('listIssues handles acts with no standardResult instances', async () => {
     await fs.unlink(reportPath).catch(() => {});
   }
 });
+
+// Returns the History section of a listIssues page, from its heading to the next heading.
+const getHistory = (answerPage: string) => {
+  const start = answerPage.indexOf('<h2>History</h2>');
+  const end = answerPage.indexOf('<h2>Issues reported</h2>');
+  assert.ok(start > -1 && end > start, 'History section exists before the issues');
+  return parse(answerPage.slice(start, end));
+};
+
+// Returns the text, and the link destination if any, of each item in a History list.
+const getHistoryItems = (history: ReturnType<typeof parse>) => history
+.querySelectorAll('ol > li')
+.map(li => ({
+  text: li.text.trim(),
+  href: li.querySelector('a')?.getAttribute('href') ?? null
+}));
+
+test('listIssues History of an older report lists all reports, with this one unlinked and no retest question', async () => {
+  const result = await answer('260101T0000/mix');
+  const history = getHistory(result.answerPage);
+  const items = getHistoryItems(history);
+  assert.equal(items.length, 2);
+  assert.match(items[0]!.text, /^\d+ days? ago \(oldest; this report\)$/);
+  assert.equal(items[0]!.href, null);
+  assert.match(items[1]!.text, /^\d+ days? ago \(latest\)$/);
+  assert.equal(items[1]!.href, '/listIssues.html/260202T0000/new');
+  assert.ok(!result.answerPage.includes('Should Kilotest retest the page?'));
+});
+
+test('listIssues History of the latest report ends with the retest question', async () => {
+  const result = await answer('260202T0000/new');
+  const history = getHistory(result.answerPage);
+  const items = getHistoryItems(history);
+  assert.equal(items.length, 2);
+  assert.match(items[0]!.text, /^\d+ days? ago \(oldest\)$/);
+  assert.equal(items[0]!.href, '/listIssues.html/260101T0000/mix');
+  assert.match(items[1]!.text, /^\d+ days? ago \(latest; this report\)$/);
+  assert.equal(items[1]!.href, null);
+  const retestLink = history.querySelector('ol + p > a');
+  assert.equal(retestLink?.text, 'Should Kilotest retest the page?');
+  assert.equal(retestLink?.getAttribute('href'), '/requestRetestForm.html/260202T0000/new');
+});
+
+test('listIssues History of the only report about a page says so and asks about retesting', async () => {
+  const result = await answer('260101T0001/ct');
+  const history = getHistory(result.answerPage);
+  assert.equal(getHistoryItems(history).length, 0);
+  const paragraphs = history.querySelectorAll('p');
+  assert.equal(paragraphs[0]?.text, 'This is the only report about the page.');
+  assert.equal(paragraphs[1]?.querySelector('a')?.getAttribute('href'), '/requestRetestForm.html/260101T0001/ct');
+});
+
+test('listIssues History tags only the ends of a list of 3 reports and the current report', async () => {
+  const fs = await import('node:fs/promises');
+  const mixJSON = await fs.readFile(path.join(realUtil.reportsPath(), '260101T0000-mix.json'), 'utf8');
+  const report = JSON.parse(mixJSON);
+  report.jobData.endTime = '26-01-15T00:10';
+  const reportPath = path.join(realUtil.reportsPath(), '260115T0000-mid.json');
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    // From the middle report:
+    let items = getHistoryItems(getHistory((await answer('260115T0000/mid')).answerPage));
+    assert.equal(items.length, 3);
+    assert.match(items[0]!.text, /\(oldest\)$/);
+    assert.match(items[1]!.text, /^\d+ days? ago \(this report\)$/);
+    assert.equal(items[1]!.href, null);
+    assert.match(items[2]!.text, /\(latest\)$/);
+    // From the latest report:
+    items = getHistoryItems(getHistory((await answer('260202T0000/new')).answerPage));
+    assert.match(items[1]!.text, /^\d+ days? ago$/);
+    assert.equal(items[1]!.href, '/listIssues.html/260115T0000/mid');
+  }
+  finally {
+    await fs.unlink(reportPath);
+  }
+});

package/web/{listReports → listPages}/index.html

@@ -30,8 +30,7 @@
       </ul>
       <p>__noClaimed__</p>
       <h2>Already tested</h2>
-      <p>Kilotest has tested __which__ pages.</p>
-      __testedPages__
+__testedPages__
     </main>
   </body>
 </html>

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 Page',
+      '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 Page');
+  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 Page', 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/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/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

@@ -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__'));