@jrpool/kilotest 57.3.0 → 58.2.4

package/api/orderNewTest.test.ts

@@ -121,7 +121,7 @@ test('orderNewTest rejects an already-tested page', async () => {
   const disposition = body['response content']['disposition of your order'] as any;
   assert.ok(
     disposition['what happens next']
-    .includes('a report about a page with the same description and URL is available.')
+    .includes('a report about a page with the same description or URL is available.')
   );
   assert.equal(disposition['report identifier'], null);
 });

package/api/orderNewTest.ts

@@ -100,7 +100,7 @@ export const response = async (args: string[]) => {
       requestDisposition = {
         'what happens next': `Your order will not be processed, because ${getRequestFailureReason(
           orderResult.result,
-          {result: 'reportExists', reason: 'a report about a page with the same description and URL is available.'}
+          {result: 'reportExists', reason: 'a report about a page with the same description or URL is available.'}
         )}`,
         'report identifier': null,
         'how you can check for completion': 'Not applicable.',

package/api/requestNewTest.test.ts

@@ -118,7 +118,7 @@ test('requestNewTest rejects an already-tested page', async () => {
   const disposition = body['response content']['disposition of your request'] as any;
   assert.ok(
     disposition['what happens next']
-    .includes('a report about a page with the same description and URL is available.')
+    .includes('a report about a page with the same description or URL is available.')
   );
   assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });

package/api/requestNewTest.ts

@@ -84,7 +84,7 @@ export const response = async (args: string[]) => {
         howToCheck: 'You can call the listReports tool to learn whether the page has been tested and a report is available.',
         howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been tested and a report is available.`
       },
-      {result: 'reportExists', reason: 'a report about a page with the same description and URL is available.'}
+      {result: 'reportExists', reason: 'a report about a page with the same description or URL is available.'}
     );
   }
   // Create the response content.

package/index.test.ts

@@ -476,7 +476,7 @@ test('POST /requestNewTest.html with an already-tested URL returns an error', as
     why: 'Because accessibility matters'
   });
   assert.equal(res.statusCode, 400);
-  assert.ok(res.body.includes('already been tested'));
+  assert.ok(res.body.includes('same description or URL is already available'));
 });
 
 test('POST /requestNewTest.html with invalid data returns an error', async () => {

package/index.ts

@@ -23,7 +23,6 @@ import {
   isReportError,
   getReportPath,
   hiddenReportsPath,
-  isReportAvailable,
   isTimeStamp,
   isJobID,
   isURL,
@@ -949,27 +948,19 @@ const handleRequest = async (request: IncomingMessage, response: ServerResponse)
         const {description, url, why} = postData as {description?: string; url: string; why?: string};
         // If the request is valid:
         if (description && isURL(url) && why && await isAllowedTarget(url)) {
-          // If a report on the page is already available:
-          if (await isReportAvailable(description, url)) {
-            // Report the error.
-            await serveError({message: 'ERROR: Page has already been tested'}, response, true);
+          // Serve headers for a response.
+          setHeaders('text/html', pathname, 'ultra');
+          // Get the answer data.
+          const answerData = await answer.requestNewTest(description, url, why);
+          // If they are valid:
+          if (answerData.status === 'ok') {
+            // Serve the answer page.
+            response.end(answerData.answerPage);
           }
-          // Otherwise, i.e. if no report on the page is available:
+          // Otherwise, i.e. if they are invalid:
           else {
-            // Serve headers for a response.
-            setHeaders('text/html', pathname, 'ultra');
-            // Get the answer data.
-            const answerData = await answer.requestNewTest(description, url, why);
-            // If they are valid:
-            if (answerData.status === 'ok') {
-              // Serve the answer page.
-              response.end(answerData.answerPage);
-            }
-            // Otherwise, i.e. if they are invalid:
-            else {
-              // Report the error.
-              await serveError({message: answerData.message}, response, true);
-            }
+            // Report the error.
+            await serveError({message: answerData.message}, response, true);
           }
         }
         // Otherwise, i.e. if the request is invalid:

package/package.json

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

package/test/fixtures/buildFixtures.ts

@@ -203,11 +203,20 @@ const main = async () => {
   const preventedCatalog = {
     '0': catalogItem('IMG', 'An image', '/html/body/img[1]', '0:0:200:100')
   };
+  // As in real reports, the prevented engine has a test act, with no standard result.
+  const preventedAlfaAct = {
+    type: 'test',
+    which: engineAlfa,
+    startTime: '26-01-01T00:00',
+    data: {prevented: true, error: 'page timed out'},
+    endTime: '26-01-01T00:01'
+  };
   const preventedActs = [
     testAct(engineAxe, [
       instance('r11', 'The image has no alt text', 'failed',
         issueLinkNoText, 0, 2, 1)
-    ])
+    ]),
+    preventedAlfaAct
   ];
   const preventedReport = report('260101T0006-prv', 'Prevented Page',
     'https://example.com/prevented', preventedActs, preventedCatalog);

package/test/fixtures/db/reports/260101T0006-prv.json

@@ -42,6 +42,16 @@
           }
         }
       }
+    },
+    {
+      "type": "test",
+      "which": "alfa",
+      "startTime": "26-01-01T00:00",
+      "data": {
+        "prevented": true,
+        "error": "page timed out"
+      },
+      "endTime": "26-01-01T00:01"
     }
   ],
   "jobData": {

package/util.test.ts

@@ -773,6 +773,21 @@ test('processTestRequest returns a reportExists error when a report already exis
   assert.equal(result, 'reportExists');
 });
 
+test('processTestRequest returns a reportExists error when a report exists about a page with the same description', async () => {
+  const {result} = await processTestRequest(
+    'because accessibility', {description: 'Mixed Outcomes Page', url: 'https://example.com/drifted'}
+  );
+  assert.equal(result, 'reportExists');
+});
+
+test('processTestRequest returns a reportExists error when a report exists about a page with an equivalent URL', async () => {
+  // The URL differs from that of the report only by a www prefix, a trailing slash, and case.
+  const {result} = await processTestRequest(
+    'because accessibility', {description: 'Drifted Page', url: 'https://www.Example.com/mixed/'}
+  );
+  assert.equal(result, 'reportExists');
+});
+
 test('processTestRequest returns a queueFull error once the pending-request queue is full', {timeout: 500}, async () => {
   // Fill testRequests.json with 20 pending requests, all for the same URL, so the total
   // pending count (summed across all URLs' request arrays) reaches the cap directly,
@@ -972,6 +987,23 @@ test('processTestRequest returns "url" for a page matching a queued job by URL',
   }
 });
 
+test('processTestRequest returns "url" for a page matching a queued job by an equivalent URL', async () => {
+  const queuedPath = path.join(jobsPath(), 'queue', 'que.json');
+  await fs.writeFile(queuedPath, getJSON({
+    target: {what: 'Some Queued Page', url: 'https://example.com/queued-url'}
+  }));
+  try {
+    // The URL differs from that of the job only by a www prefix, a trailing slash, and case.
+    const {result} = await processTestRequest(
+      'because', {description: 'A Different Page', url: 'https://www.Example.com/queued-url/'}
+    );
+    assert.equal(result, 'url');
+  }
+  finally {
+    await fs.unlink(queuedPath);
+  }
+});
+
 test('processTestRequest returns "nonreport" when the cited report does not exist', async () => {
   // Cite a timeStamp/jobID that does not correspond to any available report.
   const {result} = await processTestRequest('because', {timeStamp: '999999T9999', jobID: 'xxx'});
@@ -1244,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');
 });
@@ -1419,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';
@@ -1682,6 +1764,20 @@ test('orderJob returns a reportExists error when a report already exists for the
   assert.equal(result, 'reportExists');
 });
 
+test('orderJob returns a reportExists error when a report exists about a page with the same description', async () => {
+  const {result} = await orderJob(
+    {description: 'Mixed Outcomes Page', url: 'https://example.com/drifted'}, 'because accessibility matters here'
+  );
+  assert.equal(result, 'reportExists');
+});
+
+test('orderJob returns a reportExists error when a report exists about a page with the same URL', async () => {
+  const {result} = await orderJob(
+    {description: 'Drifted Page', url: 'https://example.com/mixed'}, 'because accessibility matters here'
+  );
+  assert.equal(result, 'reportExists');
+});
+
 test('orderJob returns "description" for a page matching a claimed job by description', async () => {
   const claimedPath = path.join(jobsPath(), 'claimed', 'clm.json');
   await fs.writeFile(claimedPath, getJSON({

package/util.ts

@@ -77,8 +77,8 @@ export type TestRequest = {
 // Test requests by URL.
 export type TestRequests = Record<string, TestRequest[]>;
 
-// Test request addition result. 'reportExists' means a report already exists for a
-// page a newTest request or order named (an outcome), distinct from the 'retest'
+// Test request addition result. 'reportExists' means a report already exists about a
+// page with the description or URL that a newTest request or order named (an outcome), distinct from the 'retest'
 // requestType discriminant elsewhere in this file, which means the caller asked to
 // retest a page that already has a report (a request kind); the two must not be
 // confused with one another.
@@ -122,6 +122,7 @@ export type AnnotatedAct = Act & {
 // and the else/after-return branch is narrowed to UsableReport.
 export type UsableReport = Omit<Report, 'target' | 'catalog' | 'jobData' | 'acts'> & {
   error?: never;
+  id: string;
   target: {what: string; url: string};
   catalog: Catalog;
   jobData: NonNullable<Report['jobData']> & {endTime: string; issuelessRules?: string[]};
@@ -792,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.
@@ -841,8 +880,9 @@ const getApprovedJobProperty = async (
       // Return this.
       return 'description';
     }
-    // Otherwise, if a job with the URL is in the category:
-    if (jobsData.some(job => job.url === url)) {
+    // Otherwise, if a job with an equivalent URL is in the category:
+    const miniURL = minifyURL(url);
+    if (jobsData.some(job => minifyURL(job.url) === miniURL)) {
       // Return this.
       return 'url';
     }
@@ -951,13 +991,11 @@ export const processTestRequest = (
       // Return this.
       return {result: 'superseded', description, url};
     }
-    // Otherwise, if the request is to test a new page for which a report already exists:
-    if (requestType === 'newTest') {
-      const reportExtracts = await getReportExtracts();
-      if (reportExtracts.some(report => report.description === description && report.url === url)) {
-        // Return this.
-        return {result: 'reportExists', description, url};
-      }
+    // Otherwise, if the request is to test a new page and a report already exists about a
+    // page with the same description or URL:
+    if (requestType === 'newTest' && await isReportAvailable(description, url)) {
+      // Return this.
+      return {result: 'reportExists', description, url};
     }
     // Otherwise, i.e. if the request is genuinely new, if the queue of requests awaiting
     // approval is already full (a cap of 0 means no limit, so the queue is never full):
@@ -1070,13 +1108,11 @@ export const orderJob = (
       // Return this.
       return {result: 'superseded', description, url};
     }
-    // Otherwise, if the order is to test a new page for which a report already exists:
-    if (!('timeStamp' in target)) {
-      const reportExtracts = await getReportExtracts();
-      if (reportExtracts.some(report => report.description === description && report.url === url)) {
-        // Return this.
-        return {result: 'reportExists', description, url};
-      }
+    // Otherwise, if the order is to test a new page and a report already exists about a
+    // page with the same description or URL:
+    if (!('timeStamp' in target) && await isReportAvailable(description, url)) {
+      // Return this.
+      return {result: 'reportExists', description, url};
     }
     // Otherwise, if the job queue is already full (a cap of 0 means no limit, so the
     // queue is never full):

package/web/listDiagnoses/index.html

@@ -14,28 +14,15 @@
     <main>
       <h1><a href="/">Kilotest</a>: Diagnoses of <q>__issue__</q> violation by HTML element __catalogIndex__ on __target__ page</h1>
       <h2>Basics</h2>
-      <h3>About the __target__ page</h3>
-      <ul>
-        <li>URL: __urlLink__</li>
-        <li>__testInfo__</li>
-      </ul>
-      <h3>About HTML element __catalogIndex__</h3>
-      <ul>
-        <li>Tag name: <code>__tagName__</code></li>
-        <li>Text: __text__</li>
-        <li>Start tag: <code>__startTag__</code></li>
-        <li>XPath: <code>__pathID__</code></li>
-        <li>Bounding box: __box__</li>
-      </ul>
+      <h3>About the page</h3>
+__pageFacts__
+      <h3>About the issue</h3>
+__issueFacts__
+      <h3>About the violator</h3>
+__violatorFacts__
       <ul class="nav">
         __takeMeThere__
       </ul>
-      <h3>About the <q>__issue__</q> issue</h3>
-      <ul>
-        <li>Why it matters: __why__</li>
-        <li>Priority: __priority__</li>
-        <li>Related WCAG standard: __wcag__</li>
-      </ul>
       <h2>Diagnoses</h2>
       <p>Here is how rule engines diagnose the <q>__issue__</q> issue for HTML element __catalogIndex__ of the __target__ page.</p>
       <ol>

package/web/listDiagnoses/index.ts

@@ -14,10 +14,12 @@ import {
   ruleEngines
 } from '../../util.ts';
 import {
+  getIssueFactsLines,
   getPageDataStrings,
+  getPageFactsLines,
+  getReportData,
   getTextFragmentHref,
-  getWCAGLink,
-  getWeightName
+  getViolatorFactsLines
 } from '../util.ts';
 import {issues as issueSpecs} from 'testaro-issues';
 
@@ -32,37 +34,33 @@ const populateQuery = async (
   pathID: string | null,
   query: Record<string, any>
 ) => {
-  // Get descriptions of the page facts.
-  const pageDataStrings = await getPageDataStrings(timeStamp, jobID);
+  // Get the report.
+  const report = await getReport(timeStamp, jobID);
   // If this failed:
-  if (pageDataStrings.error !== undefined) {
+  if (isReportError(report)) {
     // Populate the query with the reason.
-    query.error = pageDataStrings.error;
+    query.error = report.error;
     // Stop populating the query.
     return;
   }
-  const {testInfo, url, urlLink, description} = pageDataStrings;
-  // Otherwise, i.e. if it succeeded, get the report.
-  const report = await getReport(timeStamp, jobID);
+  // Otherwise, i.e. if it succeeded, get descriptions of the page facts.
+  const pageDataStrings = getPageDataStrings(report);
   // If this failed:
-  if (isReportError(report)) {
+  if (pageDataStrings.error !== undefined) {
     // Populate the query with the reason.
-    query.error = report.error;
+    query.error = pageDataStrings.error;
     // Stop populating the query.
     return;
   }
+  const {testInfo, url, description} = pageDataStrings;
   const {catalog} = report;
-  // Otherwise, i.e. if it succeeded, get the catalog item of the specified violator.
-  const catalogItem = catalog[catalogIndex];
-  const boxID = catalogItem?.boxID;
-  const startTag = catalogItem?.startTag;
-  const tagName = catalogItem?.tagName;
-  const text = catalogItem?.text;
   query.catalogIndex = catalogIndex;
   const lines: string[] = [];
   const margin = ' '.repeat(6);
+  const catalogItem = catalog[catalogIndex];
+  // If the violator has a linkable text item, add a take-me-there link.
   if (catalogIndex && catalogItem?.textLinkable) {
-    const href = getTextFragmentHref(text as string, url);
+    const href = getTextFragmentHref(catalogItem.text as string, url);
     const label = `Take me to element ${catalogIndex} on the page (in a new tab)`;
     const link = `<a href="${href}" target="_blank" aria-label="${label}">Take me there</a>`;
     query.takeMeThere = `${margin}    <p>${link}</p>`;
@@ -70,10 +68,10 @@ const populateQuery = async (
   else {
     query.takeMeThere = '';
   }
-  // Add facts about the issue to the query.
+  // Add facts about the page to the query.
   query.target = description;
-  query.urlLink = urlLink;
   query.testInfo = testInfo;
+  query.pageFacts = getPageFactsLines(pageDataStrings, getReportData(report), margin).join('\n');
   query.issue = issueSpecs[issueID]?.summary;
   // If adding the issue summary failed:
   if (!query.issue) {
@@ -82,29 +80,9 @@ const populateQuery = async (
     // Stop populating the query.
     return;
   }
-  // Otherwise, i.e. if it succeeded, get the issue details.
-  const issue = issueSpecs[issueID]!;
-  const {wcag, weight, why} = issue;
-  query.why = why;
-  query.priority = getWeightName(weight);
-  query.wcag = `<a href="${getWCAGLink(wcag)}">${wcag}</a>`;
-  query.tagName = tagName || 'HTML';
-  if (text && !['HTML', 'BODY', 'HEAD', 'SCRIPT', 'STYLE', 'NOSCRIPT'].includes(tagName as string)) {
-    const textString = text.split('\n').join(' … ');
-    query.text = `<q>${htmlSafe(textString)}</q>`;
-  }
-  else {
-    query.text = '[not applicable]';
-  }
-  query.startTag = htmlSafe(startTag ?? '') || '[not obtained]';
-  query.pathID = pathID || '[not obtained]';
-  if (boxID) {
-    const dims = boxID.split(':');
-    query.box = `x = ${dims[0]}, y = ${dims[1]}, width = ${dims[2]}, height = ${dims[3]}`;
-  }
-  else {
-    query.box = '[not obtained]';
-  }
+  // Otherwise, i.e. if it succeeded, add the issue-facts and violator-facts lists to the query.
+  query.issueFacts = getIssueFactsLines(report, issueID, margin).join('\n');
+  query.violatorFacts = getViolatorFactsLines(report, issueID, catalogIndex, pathID, margin).join('\n');
   // Initialize an array of diagnoses.
   const diagnoses: any[] = [];
   // For each violating standard instance that pertains to this combination of issue and violator:

package/web/listDiagnoses/listDiagnoses.test.ts

@@ -33,7 +33,7 @@ mock.module('../../util.ts', {
 mock.module('../util.ts', {
   exports: {
     ...realWebUtil,
-    getPageDataStrings: async (...args: any[]) => {
+    getPageDataStrings: (...args: any[]) => {
       if (pageDataStringsOverride !== null) {
         return pageDataStringsOverride;
       }
@@ -108,7 +108,7 @@ test('listDiagnoses returns ok with no diagnoses for a nonexistent catalog index
   assert.ok(!diagnosisTexts.some(t => t.includes('The link does not have an accessible name')));
 });
 
-test('listDiagnoses returns an error when getReport fails after getPageDataStrings succeeds', async () => {
+test('listDiagnoses returns an error when getReport fails', async () => {
   getReportCallCount = 0;
   failGetReportOnCall = 1;
   try {
@@ -121,6 +121,18 @@ test('listDiagnoses returns an error when getReport fails after getPageDataStrin
   }
 });
 
+test('listDiagnoses returns an error when getPageDataStrings fails after getReport succeeds', async () => {
+  pageDataStringsOverride = {error: 'Page data strings error'};
+  try {
+    const result = await answer('linkNoText/260101T0000/mix/0');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Page data strings error');
+  }
+  finally {
+    pageDataStringsOverride = null;
+  }
+});
+
 test('listDiagnoses includes a take-me-there link for a text-linkable catalog item', async () => {
   const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportsDir = path.join(dbDir, 'reports');

package/web/listIssues/index.html

@@ -13,20 +13,20 @@
   <body>
     <main>
       <h1><a href="/">Kilotest</a>: Issues reported for __target__</h1>
-      <h2>About the __target__ page</h2>
-      <ul>
-        <li>URL: __urlLink__</li>
-        <li>__testInfo__</li>
-        __preventions__
-      </ul>
+
+      <h2>About the tests</h2>
+      <details>
+        <summary>How to deal with the issues</summary>
+        <h3>Do it yourself</h3>
+        <p>Explore the issues below in as much detail as you want. Decide which ones are actual defects. Plan and implement corrections.</p>
+        <h3>Or use AI</h3>
+        <p>Make Kilotest available to your AI assistant. There are <a href="/tutorialAI.html">step-by-step instructions</a> for this.</p>
+        <p>After that, you can ask:</p>
+        <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>Issues reported</h2>
-      <h3>Summary</h3>
-      <p>__reporterCount__ reported issues (__reporters__)</p>
-      <p>__issueCount__ reported (__highestCount__ highest, __highCount__ high, __lowCount__ low, __lowestCount__ lowest priority)</p>
-      <p>__violatorCount__ reported</p>
-      <p>Download the <a href="/fullReport.json/__timeStamp__/__jobID__">full technical report</a></p>
-      <h3>Details</h3>
       <details>
         <summary>Highest priority: __highestCount__</summary>
         <ul class="headed">