@jrpool/kilotest 46.1.2 → 48.0.0

package/web/listIssues/{listIssues.test.js → listIssues.test.ts}

@@ -1,45 +1,39 @@
 /*
-  listIssues.test.js
-  UI tests for web/listIssues/index.js using the fixture corpus.
+  listIssues.test.ts
+  UI tests for web/listIssues/index.ts using the fixture corpus.
 */
 
 // IMPORTS
 
-const {test, before, after} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const {parse} = require('node-html-parser');
-
-// Monkey-patch util functions before requiring index, so that index.js
-// destructures the patched versions.
-const util = require('../../util');
-const realIsHidden = util.isHidden;
-const realGetPageDataStrings = util.getPageDataStrings;
-let isHiddenCallCount = 0;
-let forceHiddenOnCall = -1;
-let pageDataStringsOverride = null;
-util.isHidden = async (timeStamp, jobID) => {
-  isHiddenCallCount++;
-  if (isHiddenCallCount === forceHiddenOnCall) {
-    return true;
+import {test, before, after, mock} from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import {parse} from 'node-html-parser';
+
+// Mock the util functions called by index.ts before requiring it, so that
+// it imports the mocked versions. Other exports delegate to the real module.
+import * as realUtil from '../../util.ts';
+let pageDataStringsOverride: any = null;
+mock.module('../../util.ts', {
+  exports: {
+    ...realUtil,
+    getPageDataStrings: async (...args: any[]) => {
+      if (pageDataStringsOverride !== null) {
+        return pageDataStringsOverride;
+      }
+      return (realUtil.getPageDataStrings as any)(...args);
+    }
   }
-  return realIsHidden(timeStamp, jobID);
-};
-util.getPageDataStrings = async (...args) => {
-  if (pageDataStringsOverride !== null) {
-    return pageDataStringsOverride;
-  }
-  return realGetPageDataStrings(...args);
-};
+} as any);
 
-const {answer} = require('./index');
+const {answer} = await import('./index.ts') as any;
 
 // SETUP AND TEARDOWN
 
 const savedDBDir = process.env.DB_DIR;
 
-before(() => {
-  process.env.DB_DIR = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+before(async () => {
+  process.env.DB_DIR = (await import('../../test/dbFixture.ts')).fixtureDBDir;
 });
 
 after(() => {
@@ -72,13 +66,8 @@ test('listIssues includes links to listViolators for issues in the mixed report'
   const violatorLinks = html.querySelectorAll('a[href*="listViolators.html"]');
   assert.ok(violatorLinks.length >= 2);
   const hrefs = violatorLinks.map(a => a.getAttribute('href'));
-  assert.ok(hrefs.some(href => href.includes('linkNoText')));
-  assert.ok(hrefs.some(href => href.includes('allCaps')));
-});
-
-test('listIssues returns an error status for a hidden report', async () => {
-  const result = await answer('260101T0007/hid');
-  assert.equal(result.status, 'error');
+  assert.ok(hrefs.some(href => href?.includes('linkNoText')));
+  assert.ok(hrefs.some(href => href?.includes('allCaps')));
 });
 
 test('listIssues returns an error status for a nonexistent report', async () => {
@@ -102,18 +91,6 @@ test('listIssues for the empty report shows no issue links', async () => {
   assert.equal(violatorLinks.length, 0);
 });
 
-test('listIssues returns an error when a report becomes hidden during processing', async () => {
-  isHiddenCallCount = 0;
-  forceHiddenOnCall = 2;
-  try {
-    const result = await answer('260101T0000/mix');
-    assert.equal(result.status, 'error');
-    assert.equal(result.message, 'Report is not available');
-  }
-  finally {
-    forceHiddenOnCall = -1;
-  }
-});
 
 test('listIssues includes prevention notices for the prevented report', async () => {
   const result = await answer('260101T0006/prv');
@@ -122,6 +99,23 @@ test('listIssues includes prevention notices for the prevented report', async ()
   assert.ok(result.answerPage.includes('page timed out'));
 });
 
+test('listIssues falls back to the engine ID for an unknown prevented engine', async () => {
+  const fs = await import('node:fs/promises');
+  const prvJSON = await fs.readFile(path.join(realUtil.reportsPath(), '260101T0006-prv.json'), 'utf8');
+  const report = JSON.parse(prvJSON);
+  report.jobData.preventions.unknownEngine = 'mystery failure';
+  const reportPath = path.join(realUtil.reportsPath(), '260103T0000-unk.json');
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    const result = await answer('260103T0000/unk');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('unknownEngine (unknown sponsor)'));
+  }
+  finally {
+    await fs.unlink(reportPath);
+  }
+});
+
 test('listIssues returns an error when getPageDataStrings fails after getData succeeds', async () => {
   pageDataStringsOverride = {error: 'Page data strings error'};
   try {
@@ -159,8 +153,8 @@ test('listIssues shows plural violator count for an issue with multiple violator
 
 test('listIssues handles acts with no standardResult instances', async () => {
   // Create a temporary report with an act that has no standardResult.
-  const fs = require('node:fs/promises');
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const fs = await import('node:fs/promises');
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportPath = path.join(dbDir, 'reports', '260101T0004-nsi.json');
   const report = {
     id: '260101T0004-nsi',

package/web/listReports/index.html

@@ -13,11 +13,11 @@
   <body>
     <main>
       <h1>Pages tested by <a href="/">Kilotest</a></h1>
-      <h2>Recommended for testing</h2>
+      <h2>Requested for testing</h2>
       <ol>
-        __recs__
+        __requests__
       </ol>
-      <p>__noRecs__</p>
+      <p>__noRequests__</p>
       <p>Should Kilotest <a href="requestTestForm.html">test a page</a> that is not listed below?</p>
       <h2>Queued for testing</h2>
       <ol>

package/web/listReports/{index.js → index.ts}

@@ -1,66 +1,82 @@
 /*
-  index.js
+  index.ts
   Lists all available reports.
 */
 
 // IMPORTS
 
-const {
+import {
   getAgoDays,
   getCountString,
   getJobNames,
   getMultiReportWhats,
   getObject,
   getPageDataStrings,
-  getRecs,
+  getTestRequests,
   getReportData,
   getReportExtracts,
-  isRecommendable,
   jobsPath,
-  objectSort
-} = require('../../util');
-const fs = require('fs/promises');
-const path = require('path');
+  objectSort,
+  populateTemplate
+} from '../../util.ts';
+import path from 'node:path';
 
 // FUNCTIONS
 
 // Adds parameters to a query for the answer page.
-const populateQuery = async query => {
+const populateQuery = async (query: Record<string, any>) => {
   const margin = ' '.repeat(8);
   // Initialize the classes of lines.
-  const lines = {
-    recs: [],
+  const lines: {requests: string[], queue: string[], claimed: string[], tested: string[]} = {
+    requests: [],
     queue: [],
     claimed: [],
     tested: []
   };
-  // Get the recommendations.
-  const recs = await getRecs();
-  // For each recommended URL:
-  Object.keys(recs).forEach(url => {
-    // For each of its recommendations:
-    recs[url].forEach(rec => {
-      const {what, why} = rec;
+  // 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.recs.push(`${margin}<li><code>${url}</code> (${what}): ${why}</li>`);
+      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.recs.sort();
+  lines.requests.sort();
   // Add the lines to the query.
-  query.recs = lines.recs.join('\n');
-  // Add a no-recommendations message, if applicable, to the query.
-  query.noRecs = lines.recs.length
-  ? 'Kilotest managers can <a href="enqueueForm.html">approve or reject a recommendation</a>.'
-  : 'No recommendations await approval now.';
+  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();
+  // Initialize sets of the page descriptions and URLs of jobs in both categories.
+  const jobsData = {
+    queue: {
+      descriptions: new Set(),
+      urls: new Set()
+    },
+    claimed: {
+      descriptions: new Set(),
+      urls: new Set()
+    }
+  };
   // For each job category:
-  for (const category of ['queue', 'claimed']) {
+  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));
+      const job = await getObject(path.join(jobsPath(), category, fileName)) as {target: {url: string, what: string}};
+      // Get the description and URL of its page.
+      const {target} = job;
+      const {what, url} = target;
+      // Ensure they are in the sets of properties of the category.
+      jobsData[category].descriptions.add(what);
+      jobsData[category].urls.add(url);
       // Add a line.
       lines[category].push(`${margin}<li><code>${job.target.url}</code> (${job.target.what})</li>`);
     }
@@ -81,14 +97,21 @@ const populateQuery = async query => {
   const multiReportWhats = await getMultiReportWhats();
   // Sort them primarily by page description and secondarily by completion time.
   let sortedExtracts = objectSort(reportExtracts, 'reportTime', 'alpha');
-  sortedExtracts = objectSort(sortedExtracts, 'what', 'alpha');
+  sortedExtracts = objectSort(sortedExtracts, 'description', 'alpha');
   // For each report:
   for (const extract of sortedExtracts) {
-    const {jobID, timeStamp, url, what} = extract;
+    const {jobID, timeStamp, url, description, superseded} = extract;
     // Get data about it.
     const reportData = await getReportData(timeStamp, jobID);
+    // If this failed:
+    if (reportData.error !== undefined) {
+      console.error(reportData.error);
+      // Populate the query with the reason.
+      query.error = reportData.error;
+      // Stop populating the query.
+      return;
+    }
     const {
-      error,
       issueCount,
       preventedEngineCount,
       preventedEngineNames,
@@ -96,21 +119,13 @@ const populateQuery = async query => {
       reporterCount,
       violatorCount
     } = reportData;
-    // If this failed:
-    if (error) {
-      console.error(error);
-      // Populate the query with the reason.
-      query.error = error;
-      // Stop populating the query.
-      return;
-    }
     // Otherwise, i.e. if it succeeded, add lines about the report.
     lines.tested.push(`${margin}<details>`);
     const daysAgo = getAgoDays(timeStamp);
-    const pageDataStrings = await getPageDataStrings(timeStamp, jobID, {what, url, daysAgo});
-    const {urlLink, testInfo} = pageDataStrings;
-    const testText = multiReportWhats.includes(what) ? ` (${testInfo.toLowerCase()})` : '';
-    lines.tested.push(`${margin}  <summary>${what}${testText}</summary>`);
+    const pageDataStrings = await getPageDataStrings(timeStamp, jobID, {description, url, daysAgo});
+    const {urlLink, testInfo}: any = pageDataStrings;
+    const testText = multiReportWhats.includes(description) ? ` (${testInfo.toLowerCase()})` : '';
+    lines.tested.push(`${margin}  <summary>${description}${testText}</summary>`);
     lines.tested.push(`${margin}  <ul>`);
     // Add the URL of the target to the lines.
     lines.tested.push(`${margin}    <li>URL: ${urlLink}</li>`);
@@ -125,7 +140,7 @@ const populateQuery = async query => {
       );
     }
     // Add facts about the test results to the lines.
-     let reporterString = `${getCountString(reporterCount, 'rule engine', 'rule engines')} reported issues`;
+    let reporterString = `${getCountString(reporterCount, 'rule engine', 'rule engines')} reported issues`;
     if (reporterCount) {
       const reporterNamesString = reporterNames.join(' + ');
       reporterString = `${reporterString} (${reporterNamesString})`;
@@ -141,34 +156,39 @@ const populateQuery = async query => {
     if (issueCount) {
       // Add a question link about the reported issues to the lines.
       const href = `href="listIssues.html/${timeStamp}/${jobID}"`;
-      const label = `aria-label="What ${issueCountString} reported for the ${what} page?"`;
+      const label = `aria-label="What ${issueCountString} reported for the ${description} page?"`;
       const questionString = issueCount === 1 ? 'was the issue' : 'were the issues';
       const link = `<a ${href} ${label}>What ${questionString}?</a>`;
       lines.tested.push(`${margin}    <li>${link}</li>`);
     }
-    // Add the status of, and if necessary a question link about, retesting to the lines.
-    const status = await isRecommendable(url);
-    let retestString;
-    if (status === 'claimed') {
+    let retestString: string = '';
+    // If a page with the same description or URL is being tested:
+    if (jobsData.claimed.descriptions.has(description) || jobsData.claimed.urls.has(url)) {
+      // Report this.
       retestString = 'Currently being retested';
     }
-    else if (status === 'queued') {
+    // Otherwise, if such a page is queued:
+    else if (jobsData.queue.descriptions.has(description) || jobsData.queue.urls.has(url)) {
       retestString = 'Currently in the queue for retesting';
     }
-    else {
+    // Otherwise, if no such page is being tested or queued and the report is not superseded:
+    else if (!superseded) {
+      // Make the page available for retesting.
       const href = `/requestRetestForm.html/${timeStamp}/${jobID}`;
       const retestContent = 'Should Kilotest retest the page?';
       retestString = `<a href="${href}">${retestContent}</a>`;
     }
-    lines.tested.push(`${margin}    <li>${retestString}</li>`);
+    if (retestString) {
+      lines.tested.push(`${margin}    <li>${retestString}</li>`);
+    }
     lines.tested.push(`${margin}  </ul>`);
     lines.tested.push(`${margin}</details>`);
   }
   query.testedPages = lines.tested.join('\n');
 };
 // Returns a page answering the targets question.
-exports.answer = async () => {
-  const query = {};
+export const answer = async () => {
+  const query: Record<string, any> = {};
   // Create a query to replace placeholders.
   await populateQuery(query);
   // If the query reports an error:
@@ -180,11 +200,7 @@ exports.answer = async () => {
     };
   }
   // Otherwise, i.e. if it does not report an error, get the template.
-  let answerPage = await fs.readFile(path.join(__dirname, 'index.html'), 'utf8');
-  // Replace its placeholders.
-  Object.keys(query).forEach(param => {
-    answerPage = answerPage.replace(new RegExp(`__${param}__`, 'g'), query[param]);
-  });
+  const answerPage = await populateTemplate(import.meta.dirname, query);
   // Return the populated page.
   return {
     status: 'ok',

package/web/listReports/{listReports.test.js → listReports.test.ts}

@@ -1,23 +1,23 @@
 /*
-  listReports.test.js
-  UI tests for web/listReports/index.js using the fixture corpus.
+  listReports.test.ts
+  UI tests for web/listReports/index.ts using the fixture corpus.
 */
 
 // IMPORTS
 
-const {test, before, after} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const fs = require('node:fs/promises');
-const {parse} = require('node-html-parser');
-const {answer} = require('./index');
+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 = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  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});
@@ -36,22 +36,22 @@ after(() => {
 // TESTS
 
 test('listReports returns an ok status with valid HTML', async () => {
-  const result = await answer();
+  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');
+  assert.equal(html.querySelector('title')?.text, 'Pages tested | Kilotest');
 });
 
 test('listReports includes the 8 non-hidden fixture reports as details elements', async () => {
-  const result = await answer();
+  const result: any = await answer();
   const html = parse(result.answerPage);
   const details = html.querySelectorAll('details');
   assert.equal(details.length, 8);
 });
 
 test('listReports includes the page descriptions in summary elements', async () => {
-  const result = await answer();
+  const result: any = await answer();
   const html = parse(result.answerPage);
   const summaries = html.querySelectorAll('details > summary').map(s => s.text);
   assert.ok(summaries.some(s => s.startsWith('Mixed Outcomes Page')));
@@ -62,55 +62,55 @@ test('listReports includes the page descriptions in summary elements', async ()
 });
 
 test('listReports does not include the hidden report', async () => {
-  const result = await answer();
+  const result: any = await answer();
   assert.ok(!result.answerPage.includes('Hidden Page'));
 });
 
 test('listReports includes links to listIssues for reports with issues', async () => {
-  const result = await answer();
+  const result: any = await answer();
   const html = parse(result.answerPage);
   const issueLinks = html.querySelectorAll('a[href*="listIssues.html"]');
   assert.ok(issueLinks.length > 0);
   const hrefs = issueLinks.map(a => a.getAttribute('href'));
-  assert.ok(hrefs.some(href => href.includes('260101T0000/mix')));
+  assert.ok(hrefs.some(href => href?.includes('260101T0000/mix')));
 });
 
 test('listReports includes the page URLs in the report details', async () => {
-  const result = await answer();
+  const result: any = await answer();
   assert.ok(result.answerPage.includes('https://example.com/mixed'));
   assert.ok(result.answerPage.includes('https://example.com/canttell'));
 });
 
 test('listReports includes a link to request testing a new page', async () => {
-  const result = await answer();
+  const result: any = await answer();
   const html = parse(result.answerPage);
   const testLink = html.querySelector('a[href="requestTestForm.html"]');
   assert.ok(testLink);
 });
 
-test('listReports shows recommendations when recs.json has entries', {timeout: 500}, async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
-  const recsPath = path.join(dbDir, 'jobs', 'recs.json');
-  const originalRecs = await fs.readFile(recsPath, 'utf8');
+test('listReports 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 testRecs = {
+    const testRequests = {
       'https://example.com/mixed': [
-        {what: 'Mixed Outcomes Page', why: 'Needs retesting for accessibility'}
+        {description: 'Mixed Outcomes Page', reason: 'Needs retesting for accessibility'}
       ]
     };
-    await fs.writeFile(recsPath, JSON.stringify(testRecs, null, 2));
-    const result = await answer();
+    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(recsPath, originalRecs);
+    await fs.writeFile(testRequestsPath, originalTestRequests);
   }
 });
 
 test('listReports shows queued and claimed jobs when they exist', async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  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');
@@ -124,7 +124,7 @@ test('listReports shows queued and claimed jobs when they exist', async () => {
     };
     await fs.writeFile(queueFile, JSON.stringify(queuedJob, null, 2));
     await fs.writeFile(claimedFile, JSON.stringify(claimedJob, null, 2));
-    const result = await answer();
+    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'));
@@ -138,7 +138,7 @@ test('listReports shows queued and claimed jobs when they exist', async () => {
 });
 
 test('listReports shows claimed retest status for a report with a matching claimed job', async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const claimedDir = path.join(dbDir, 'jobs', 'claimed');
   const claimedFile = path.join(claimedDir, 'claimedRetest.json');
   try {
@@ -146,7 +146,7 @@ test('listReports shows claimed retest status for a report with a matching claim
       target: {url: 'https://example.com/mixed', what: 'Mixed Outcomes Page'}
     };
     await fs.writeFile(claimedFile, JSON.stringify(claimedJob, null, 2));
-    const result = await answer();
+    const result: any = await answer();
     assert.equal(result.status, 'ok');
     assert.ok(result.answerPage.includes('Currently being retested'));
   }
@@ -156,7 +156,7 @@ test('listReports shows claimed retest status for a report with a matching claim
 });
 
 test('listReports shows queued retest status for a report with a matching queued job', async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const queueDir = path.join(dbDir, 'jobs', 'queue');
   const queueFile = path.join(queueDir, 'queuedRetest.json');
   try {
@@ -164,7 +164,7 @@ test('listReports shows queued retest status for a report with a matching queued
       target: {url: 'https://example.com/mixed', what: 'Mixed Outcomes Page'}
     };
     await fs.writeFile(queueFile, JSON.stringify(queuedJob, null, 2));
-    const result = await answer();
+    const result: any = await answer();
     assert.equal(result.status, 'ok');
     assert.ok(result.answerPage.includes('Currently in the queue for retesting'));
   }
@@ -173,18 +173,18 @@ test('listReports shows queued retest status for a report with a matching queued
   }
 });
 
-test('listReports returns an error when a report file is invalid', async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+test('listReports returns an error when a report file is invalid', {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 invalid for isValidReport (no acts or catalog).
+    // 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 = await answer();
+    const result: any = await answer();
     assert.equal(result.status, 'error');
     assert.ok(result.message);
   }
@@ -195,26 +195,24 @@ test('listReports returns an error when a report file is invalid', async () => {
 
 test('listReports shows no-reports message when the database is empty', async () => {
   // Create a temp DB with empty reports and jobs directories.
-  const os = require('node:os');
+  const os = await import('node:os');
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'listreports-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', 'recs.json'), '{}\n');
+  await fs.writeFile(path.join(tmpDir, 'jobs', 'testRequests.json'), '{}\n');
   const savedDBDir = process.env.DB_DIR;
   process.env.DB_DIR = tmpDir;
   try {
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
-    const result = await answer();
+    const {answer} = await import('./index.ts');
+    const result: any = await answer();
     assert.equal(result.status, 'ok');
     assert.ok(result.answerPage.includes('no'));
     assert.ok(result.answerPage.includes(' a '));
   }
   finally {
     process.env.DB_DIR = savedDBDir;
-    delete require.cache[require.resolve('./index')];
     await fs.rm(tmpDir, {recursive: true}).catch(() => {});
   }
 });