@jrpool/kilotest 46.1.2 → 47.0.1

package/api/{listDiagnoses.js → listDiagnoses.ts}

@@ -1,77 +1,67 @@
 /*
-  listDiagnoses.js
+  listDiagnoses.ts
   Returns details about one violator of one issue in one report and facts about all its diagnoses.
 */
 
 // IMPORTS
 
-const {
+import {z} from 'zod';
+import {
   getIssueSpec,
   getReportBasics,
   getResponseMetadata,
   getToolsFacts,
-  thisHost
-} = require('./util');
-const {getReport} = require('../util');
+  getThisHost
+} from './util.ts';
+import {getReport, getTestActInstances, isReportError} from '../util.ts';
+import {listDiagnosesResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof listDiagnosesResponseSchema>['response content'];
+// The array variant of the union allowed for the diagnoses property.
+type Diagnoses = Extract<ResponseContent['diagnoses of how the element exhibited the issue'], unknown[]>;
 
 // FUNCTIONS
 
 // Returns the response body.
-exports.response = async args => {
+export const response = async (args: string[]) => {
   const [catalogIndex = '', issueID = '', timeStamp = '', jobID = ''] = args;
-  // Initialize the response content.
-  const responseContent = {
-    'basics about the report': null,
-    'basics about the issue': null,
-    'basics about the element': null,
-    'details about the element': null,
-    'diagnoses of how the element exhibited the issue': null
-  };
+  const thisHost = getThisHost();
   // Get the report.
   const report = await getReport(timeStamp, jobID);
-  // If this failed:
-  if (report.error) {
-    // Add this to the response content.
-    responseContent['basics about the report'] = report;
-  }
-  // Otherwise, i.e. if it succeeded:
-  else {
-    // Get the basics about the report (which may be only an error message).
-    const reportBasics = await getReportBasics(timeStamp, jobID);
-    // Add them to the response content.
-    responseContent['basics about the report'] = reportBasics;
-  }
   // Get the specification of the issue.
   const issueSpec = issueID ? getIssueSpec(issueID) : null;
-  // If the issue is ignorable or not fully classified:
-  if (!issueSpec) {
-    // Add this to the response content.
-    responseContent['basics about the issue'] = {
+  // Initialize the response content.
+  const responseContent: ResponseContent = {
+    'basics about the report': isReportError(report) ? report : await getReportBasics(timeStamp, jobID),
+    'basics about the issue': {
       'error': 'No information about the specified issue is available'
-    };
-    responseContent['diagnoses of how the element exhibited the issue'] = {
+    },
+    'basics about the element': null,
+    'details about the element': null,
+    'diagnoses of how the element exhibited the issue': issueSpec ? null : {
       'error': 'No diagnoses of how the element exhibited the issue is available'
-    };
-  }
-  // Otherwise, i.e. if it is non-ignorable and fully classified:
-  else {
+    }
+  };
+  // If the issue is non-ignorable and fully classified:
+  if (issueSpec) {
     const {summary, wcag, weight, why} = issueSpec;
-    // Initialize the basics about it.
-    const issueBasics = {
+    // Add the basics about it to the response content.
+    responseContent['basics about the issue'] = {
       'identifier': issueID,
       summary,
       'impact on a user': why,
       'related WCAG standard': {
-        'layer': (wcag.length > 4 ? 'success criterion' : 'guideline'),
+        'layer': (wcag.length > 4 ? 'success criterion' : 'guideline') as 'success criterion' | 'guideline',
         'identifier': wcag
       },
-      priority: ['lowest', 'low', 'high', 'highest'][weight - 1]
+      priority: ['lowest', 'low', 'high', 'highest'][weight - 1] as 'lowest' | 'low' | 'high' | 'highest'
     };
-    // Add them to the response content.
-    responseContent['basics about the issue'] = issueBasics;
   }
-  // If the report and its catalog exist:
-  if (report.catalog) {
+  // If the report was retrieved successfully:
+  if (!isReportError(report)) {
     const catalogItem = report.catalog[catalogIndex];
     // If the violator is not in it:
     if (!catalogItem) {
@@ -101,33 +91,19 @@ exports.response = async args => {
       // If the issue is non-ignorable and fully classified:
       if (issueSpec) {
         // Initialize data about the diagnoses of the violation of the issue.
-        const diagnoses = [];
-        // For each act in the report:
-        report.acts.forEach(act => {
-          const {result, type, which} = act;
-          const instances = result?.standardResult?.instances || [];
-          // If the act is a test act with a specified rule engine:
-          if (type === 'test' && which) {
-            // For each standard instance of the act:
-            instances.forEach(instance => {
-              const {count, ordinalSeverity, outcome, ruleID, what} = instance;
-              // If the instance reports a violation of the issue by the violator:
-              if (
-                outcome !== 'cantTell'
-                &&  instance.issueID === issueID
-                &&  instance.catalogIndex === catalogIndex
-              ) {
-                // Get the diagnosis.
-                const diagnosis = {
-                  'identifier of the violated rule': ruleID !== what ? ruleID : null,
-                  'description of the violation': what,
-                  'severity of the violation on a 0-to-3 scale': ordinalSeverity,
-                  'count of violations of the rule by the element': count ?? 1
-                }
-                diagnoses.push(diagnosis);
-              }
-            });
+        const diagnoses: Diagnoses = [];
+        // For each instance reporting a violation of the issue by the violator:
+        getTestActInstances(report, {violationsOnly: true, issueID, catalogIndex})
+        .forEach(({instance}) => {
+          const {count, ordinalSeverity, ruleID, what} = instance;
+          // Get the diagnosis.
+          const diagnosis = {
+            'identifier of the violated rule': ruleID !== what ? ruleID : null,
+            'description of the violation': what,
+            'severity of the violation on a 0-to-3 scale': ordinalSeverity,
+            'count of violations of the rule by the element': count ?? 1
           }
+          diagnoses.push(diagnosis);
         });
         // Add the diagnoses to the response content.
         responseContent['diagnoses of how the element exhibited the issue'] = diagnoses;

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

@@ -1,21 +1,20 @@
 /*
-  listIssues.test.js
-  Tests for api/listIssues.js using the fixture corpus, with emphasis on outcome handling.
+  listIssues.test.ts
+  Tests for api/listIssues.ts using the fixture corpus, with emphasis on outcome handling.
 */
 
 // IMPORTS
 
-const {test, before, after} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const {response} = require('./listIssues');
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import {response} from './listIssues.ts';
 
 // 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(() => {
@@ -32,33 +31,37 @@ after(() => {
 test('listIssues returns 2 issues for the mixed-outcomes report, excluding cantTell', async () => {
   const body = await response(['260101T0000', 'mix']);
   const issues = body['response content']['basics about all issues reported in the report'];
+  assert.ok(issues);
   assert.equal(issues.length, 2);
-  const summaries = issues.map(i => i.summary).sort();
+  const summaries = issues.map((i: any) => i.summary).sort();
   assert.deepEqual(summaries, ['all-capital text', 'link not named']);
 });
 
 test('listIssues returns 0 issues for the all-cantTell report', async () => {
   const body = await response(['260101T0001', 'ct']);
   const issues = body['response content']['basics about all issues reported in the report'];
+  assert.ok(issues);
   assert.equal(issues.length, 0);
 });
 
 test('listIssues treats missing outcome as a violation, not cantTell', async () => {
   const body = await response(['260101T0002', 'no']);
   const issues = body['response content']['basics about all issues reported in the report'];
+  assert.ok(issues);
   assert.equal(issues.length, 1);
-  assert.equal(issues[0].identifier, 'linkNoText');
+  assert.equal(issues[0]!.identifier, 'linkNoText');
 });
 
 test('listIssues returns 0 issues for the empty report', async () => {
   const body = await response(['260101T0005', 'emp']);
   const issues = body['response content']['basics about all issues reported in the report'];
+  assert.ok(issues);
   assert.equal(issues.length, 0);
 });
 
 test('listIssues reports prevented rule engines for the prevented report', async () => {
   const body = await response(['260101T0006', 'prv']);
-  const details = body['response content']['details about the report'];
+  const details = body['response content']['details about the report'] as any;
   const preventions = details['test results']['rule engines that could not test the page'];
   assert.equal(preventions.length, 1);
   assert.equal(preventions[0].name, 'Alfa');
@@ -68,15 +71,18 @@ test('listIssues reports prevented rule engines for the prevented report', async
 test('listIssues includes reporter names for each issue in the mixed report', async () => {
   const body = await response(['260101T0000', 'mix']);
   const issues = body['response content']['basics about all issues reported in the report'];
+  assert.ok(issues);
   const linkIssue = issues.find(i => i.identifier === 'linkNoText');
+  assert.ok(linkIssue);
   assert.deepEqual(linkIssue['rule engines with any violations belonging to the issue'], ['Alfa', 'Axe']);
   const allCapsIssue = issues.find(i => i.identifier === 'allCaps');
+  assert.ok(allCapsIssue);
   assert.deepEqual(allCapsIssue['rule engines with any violations belonging to the issue'], ['Alfa']);
 });
 
 test('listIssues counts issues by priority correctly for the mixed report', async () => {
   const body = await response(['260101T0000', 'mix']);
-  const details = body['response content']['details about the report'];
+  const details = body['response content']['details about the report'] as any;
   const counts = details['test results']['counts of issues by priority'];
   // linkNoText weight 4 (highest), allCaps weight 1 (lowest).
   assert.equal(counts.highest, 1);
@@ -87,13 +93,13 @@ test('listIssues counts issues by priority correctly for the mixed report', asyn
 
 test('listIssues reports the superseded status for the mixed report', async () => {
   const body = await response(['260101T0000', 'mix']);
-  const basics = body['response content']['basics about the report'];
+  const basics = body['response content']['basics about the report'] as any;
   assert.equal(basics['whether a later report about the same page exists'], true);
 });
 
 test('listIssues returns an error for a nonexistent report', async () => {
   const body = await response(['999999T9999', 'xyz']);
-  const basics = body['response content']['basics about the report'];
+  const basics = body['response content']['basics about the report'] as any;
   assert.ok(basics.error);
 });
 
@@ -102,6 +108,7 @@ test('listIssues handles instances with missing issueID and null instances witho
   const issues = body['response content']['basics about all issues reported in the report'];
   // The brd fixture has one instance with duplicateID (a valid issue) and one with no issueID (skipped).
   // The alfa act has no instances array, so it should be handled as empty.
+  assert.ok(issues);
   assert.ok(issues.length >= 1);
   const ids = issues.map(i => i.identifier);
   assert.ok(ids.includes('duplicateID'));

package/api/{listIssues.js → listIssues.ts}

@@ -1,29 +1,43 @@
 /*
-  listIssues.js
+  listIssues.ts
   Returns details about one report and basics about all the issues in it.
 */
 
 // IMPORTS
 
-const {
+import {z} from 'zod';
+import {
   getIssueSpec,
   getReportBasics,
   getResponseMetadata,
   getRuleEngineFacts,
   getRuleEnginesFacts,
   getToolsFacts,
-  thisHost
-} = require('./util');
-const {getReport, getReportStats, objectSort} = require('../util');
+  getThisHost
+} from './util.ts';
+import {
+  getReport, getReportStats, getTestActInstances, getTestActs, isReportError, objectSort
+} from '../util.ts';
+import {listIssuesResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof listIssuesResponseSchema>['response content'];
 
 // FUNCTIONS
 
 // Returns the response body.
-exports.response = async args => {
+export const response = async (args: string[]) => {
   const [timeStamp = '', jobID = ''] = args;
+  const thisHost = getThisHost();
+  // Get the report.
+  const report = await getReport(timeStamp, jobID);
+  // Get the basics about the report (which may be only an error message).
+  const reportBasics = isReportError(report) ? report : await getReportBasics(timeStamp, jobID);
   // Initialize the response content.
-  const responseContent = {
-    'basics about the report': null,
+  const responseContent: ResponseContent = {
+    'basics about the report': reportBasics,
     'details about the report': null,
     'how to request that the page be retested': null,
     'how a web user can request that the page be retested': null,
@@ -31,21 +45,10 @@ exports.response = async args => {
     'how a web user can get the full report in JSON': null,
     'basics about all issues reported in the report': null
   };
-  // Get the report.
-  const report = await getReport(timeStamp, jobID);
-  // If this failed:
-  if (report.error) {
-    // Add this to the response content.
-    responseContent['basics about the report'] = report;
-  }
-  // Otherwise, i.e. if it succeeded:
-  else {
-    // Get the basics about the report (which may be only an error message).
-    const reportBasics = await getReportBasics(timeStamp, jobID);
-    // Add them to the response content.
-    responseContent['basics about the report'] = reportBasics;
-    // If the basics about the report were obtained:
-    if (!reportBasics.error) {
+  // If the report was retrieved:
+  if (!isReportError(report)) {
+    // If its basics were computed:
+    if (!('error' in reportBasics)) {
       const {
         strict = null,
         standard = null,
@@ -55,54 +58,52 @@ exports.response = async args => {
       // Get details about the job definition.
       const jobDefinitionDetails = {
         'whether the job prohibited redirection': strict,
-        'whether the native results of rule engines are reported': ['also', 'no'].includes(standard),
-        'whether standardized results are reported': ['also', 'only'].includes(standard),
+        'whether the native results of rule engines are reported': ['also', 'no'].includes(standard as string),
+        'whether standardized results are reported': ['also', 'only'].includes(standard as string),
         'device emulated by the job': device,
         'browser type used by the job': browserID
       };
       // Initialize data about the test results.
-      const ruleEngineIDs = new Set();
-      const reporterIDs = new Set();
-      const violatorIndexes = new Set();
-      const issuesData = {};
-      // For each act in the report:
-      report.acts.forEach(act => {
-        const {result, type, which} = act;
-        // If the act is a test act with a specified rule engine:
-        if (type === 'test' && which) {
-          // Ensure its rule engine is in the results data.
-          ruleEngineIDs.add(which);
-          const instances = result?.standardResult?.instances ?? [];
-          // For each standard instance of the act:
-          instances.forEach(instance => {
-            const {catalogIndex, issueID, outcome} = instance;
-            // If the instance reports a violation:
-            if (outcome !== 'cantTell') {
-              // Get the specification of its issue.
-              const issueSpec = issueID ? getIssueSpec(issueID) : null;
-              // If the instance has a non-ignorable and fully classified issue:
-              if (issueSpec) {
-                const {summary, weight, why} = issueSpec;
-                // Ensure the rule-engine ID is in the reporters data.
-                reporterIDs.add(which);
-                // If the instance has a catalog index:
-                if (catalogIndex) {
-                  // Ensure the index of the violator is in the results data.
-                  violatorIndexes.add(catalogIndex);
-                }
-                // Ensure the data about the issue are in the results data.
-                issuesData[issueID] ??= {
-                  id: issueID,
-                  summary,
-                  weight,
-                  why,
-                  reporterIDs: new Set()
-                };
-                // Ensure the reporter ID is in the data about the issue.
-                issuesData[issueID].reporterIDs.add(which);
-              }
-            }
-          });
+      const ruleEngineIDs: Set<string> = new Set();
+      const reporterIDs: Set<string> = new Set();
+      const violatorIndexes: Set<string> = new Set();
+      const issuesData: Record<string, {
+        id: string;
+        summary: string;
+        weight: number;
+        why: string;
+        reporterIDs: Set<string>;
+      }> = {};
+      // For each test act in the report:
+      getTestActs(report).forEach(act => {
+        // Ensure its rule engine is in the results data.
+        ruleEngineIDs.add(act.which!);
+      });
+      // For each violating standard instance of each test act:
+      getTestActInstances(report, {violationsOnly: true}).forEach(({act, instance}) => {
+        const {catalogIndex, issueID} = instance;
+        // Get the specification of its issue.
+        const issueSpec = issueID ? getIssueSpec(issueID) : null;
+        // If the instance has a non-ignorable and fully classified issue:
+        if (issueSpec) {
+          const {summary, weight, why} = issueSpec;
+          // Ensure the rule-engine ID is in the reporters data.
+          reporterIDs.add(act.which!);
+          // If the instance has a catalog index:
+          if (catalogIndex) {
+            // Ensure the index of the violator is in the results data.
+            violatorIndexes.add(String(catalogIndex));
+          }
+          // Ensure the data about the issue are in the results data.
+          issuesData[issueID!] ??= {
+            id: issueID!,
+            summary,
+            weight,
+            why,
+            reporterIDs: new Set()
+          };
+          // Ensure the reporter ID is in the data about the issue.
+          issuesData[issueID!]!.reporterIDs.add(act.which!);
         }
       });
       const {preventions} = report.jobData;
@@ -117,7 +118,7 @@ exports.response = async args => {
       // For each issue:
       Object.values(issuesData).forEach(issueData => {
         // Increment the count of issues with its weight.
-        weightCounts[issueData.weight - 1]++;
+        weightCounts[issueData.weight - 1]!++;
       });
       // Get details about the test results.
       const resultDetails = {
@@ -126,10 +127,10 @@ exports.response = async args => {
         'names of rule engines that reported rule violations': getRuleEnginesFacts(reporterIDs)
         .map(facts => facts.name),
         'counts of issues by priority': {
-          'highest': weightCounts[3],
-          'high': weightCounts[2],
-          'low': weightCounts[1],
-          'lowest': weightCounts[0]
+          'highest': weightCounts[3]!,
+          'high': weightCounts[2]!,
+          'low': weightCounts[1]!,
+          'lowest': weightCounts[0]!
         },
         'number of elements reported as violators': violatorIndexes.size
       };
@@ -186,12 +187,12 @@ exports.response = async args => {
         return {
           identifier: id,
           summary,
-          priority: ['lowest', 'low', 'high', 'highest'][weight - 1],
+          priority: ['lowest', 'low', 'high', 'highest'][weight - 1] as 'lowest' | 'low' | 'high' | 'highest',
           'impact on a user': why,
           'rule engines with any violations belonging to the issue': getRuleEnginesFacts(reporterIDs)
           .map(ruleEnginesFact => ruleEnginesFact.name),
           'how to get details about the issue': {
-            method: 'GET',
+            method: 'GET' as const,
             URL: `${thisHost}/api/listViolators/${id}/${timeStamp}/${jobID}`
           },
           'web users can get details about the issue at': `${thisHost}/listViolators.html/${id}/${timeStamp}/${jobID}`

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

@@ -1,14 +1,13 @@
 /*
-  listReports.test.js
-  Tests for api/listReports.js using the fixture corpus.
+  listReports.test.ts
+  Tests for api/listReports.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 {response} = require('./listReports');
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import {response} from './listReports.ts';
 
 // CONSTANTS
 
@@ -28,8 +27,8 @@ const fixtureIds = [
 
 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(() => {
@@ -47,7 +46,7 @@ test('listReports returns basics about all 8 non-hidden reports', async () => {
   const body = await response();
   const reportsBasics = body['response content']['basics about all available reports'];
   assert.equal(reportsBasics.length, 8);
-  const ids = reportsBasics.map(b => b.identifier).sort();
+  const ids = reportsBasics.map((b: any) => b.identifier).sort();
   const expectedIds = fixtureIds.map(([ts, jid]) => `${ts}-${jid}`).sort();
   assert.deepEqual(ids, expectedIds);
 });
@@ -55,14 +54,14 @@ test('listReports returns basics about all 8 non-hidden reports', async () => {
 test('listReports does not include the hidden report', async () => {
   const body = await response();
   const reportsBasics = body['response content']['basics about all available reports'];
-  const ids = reportsBasics.map(b => b.identifier);
+  const ids = reportsBasics.map((b: any) => b.identifier);
   assert.ok(!ids.includes('260101T0007-hid'), 'hidden report must not appear in listReports');
 });
 
 test('listReports sorts reports by page description and then by completion time', async () => {
   const body = await response();
   const reportsBasics = body['response content']['basics about all available reports'];
-  const descriptions = reportsBasics.map(b => b['tested web page'].description);
+  const descriptions = reportsBasics.map((b: any) => b['tested web page'].description);
   // All CantTell Page, Empty Results Page, Mixed Outcomes Page, Mixed Outcomes Page, No Outcomes Page, Prevented Page.
   assert.deepEqual(
     descriptions,
@@ -78,16 +77,18 @@ test('listReports sorts reports by page description and then by completion time'
     ]
   );
   // The two Mixed Outcomes Page reports should be sorted by completion time (older first).
-  const mixedReports = reportsBasics.filter(b => b['tested web page'].description === 'Mixed Outcomes Page');
-  assert.equal(mixedReports[0].identifier, '260101T0000-mix');
-  assert.equal(mixedReports[1].identifier, '260202T0000-new');
+  const mixedReports = reportsBasics.filter((b: any) => b['tested web page'].description === 'Mixed Outcomes Page');
+  assert.equal(mixedReports[0]!.identifier, '260101T0000-mix');
+  assert.equal(mixedReports[1]!.identifier, '260202T0000-new');
 });
 
 test('listReports marks the superseded report correctly', async () => {
   const body = await response();
   const reportsBasics = body['response content']['basics about all available reports'];
-  const mix = reportsBasics.find(b => b.identifier === '260101T0000-mix');
-  const newer = reportsBasics.find(b => b.identifier === '260202T0000-new');
+  const mix = reportsBasics.find((b: any) => b.identifier === '260101T0000-mix');
+  const newer = reportsBasics.find((b: any) => b.identifier === '260202T0000-new');
+  assert.ok(mix);
+  assert.ok(newer);
   assert.equal(mix['whether a later report about the same page exists'], true);
   assert.equal(newer['whether a later report about the same page exists'], false);
 });

package/api/listReports.ts

@@ -0,0 +1,87 @@
+/*
+  listReports.ts
+  Returns basics about all the available reports.
+*/
+
+// IMPORTS
+
+import {z} from 'zod';
+import {getReportBasics, getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
+import {getReportExtracts} from '../util.ts';
+import {listReportsResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof listReportsResponseSchema>['response content'];
+
+// FUNCTIONS
+
+// Returns the response body.
+export const response = async () => {
+  const thisHost = getThisHost();
+  // Initialize an array of basics about the reports.
+  const reportsBasics: ResponseContent['basics about all available reports'] = [];
+  // Get extracts of all available reports.
+  const reportExtracts = await getReportExtracts();
+  // For each report:
+  for (const extract of reportExtracts) {
+    const {jobID, timeStamp} = extract;
+    // Get the basics about it.
+    const reportBasics = await getReportBasics(timeStamp, jobID, extract);
+    // Add the basics, with instructions for getting details, to the array.
+    reportsBasics.push({
+      ...reportBasics,
+      'how to get details about the report': {
+        method: 'GET',
+        URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`
+      },
+      'web users can get details about the report at': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+    });
+  }
+  // Sort the array by page description and secondarily by completion recency.
+  reportsBasics.sort((a, b) => {
+    if (a['tested web page'].description !== b['tested web page'].description) {
+      return a['tested web page']
+      .description
+      .localeCompare(b['tested web page'].description, 'en', {sensitivity: 'base'});
+    }
+    return a['completion date and time'].localeCompare(b['completion date and time']);
+  });
+  // Create the response content.
+  const responseContent: ResponseContent = {
+    'basics about all available reports': reportsBasics,
+    'how to request that a page with no report be tested': {
+      method: 'POST',
+      URL: `${thisHost}/api/requestTest`,
+      'request body': {
+        description: '10- to 100-character description of the page conforming to the naming convention used in this list of reports',
+        URL: '12- to 300-character URL of the page, including the https:// scheme and any query',
+        reason: '20- to 100-character reason why the page should be tested'
+      },
+      'how to check whether the request has been fulfilled': 'use this listReports tool to determine whether a report about the page has become available (typical wait time: 1 hour to 1 day)'
+    },
+    'how a web user can request that the page be tested': {
+      URL: `${thisHost}/requestTestForm.html`
+    }
+  };
+  // Create a response body.
+  const body = {
+    'tool collection': getToolsFacts(),
+    'tool name': 'listReports',
+    'this request': {
+      description: 'Provide basics about all available reports.',
+      method: 'GET',
+      URL: `${thisHost}/api/listReports`,
+      'closest ancestor request': null
+    },
+    'URLs of similar requests for web users': {
+      'this request': `${thisHost}/listReports.html`,
+      'closest ancestor request': null
+    },
+    'response metadata': getResponseMetadata(),
+    'response content': responseContent
+  };
+  // Return it.
+  return body;
+};