@jrpool/kilotest 46.1.2 → 48.0.0

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

@@ -1,46 +1,49 @@
 /*
-  listViolators.test.js
-  UI tests for web/listViolators/index.js using the fixture corpus.
+  listViolators.test.ts
+  UI tests for web/listViolators/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');
+import {test, before, after, mock} 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';
 
-// Monkey-patch util functions before requiring index, so that index.js
-// destructures the patched versions.
-const util = require('../../util');
-const realGetReport = util.getReport;
-const realGetPageDataStrings = util.getPageDataStrings;
+// 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 getReportCallCount = 0;
 let failGetReportOnCall = -1;
-let pageDataStringsOverride = null;
-util.getReport = async (...args) => {
-  getReportCallCount++;
-  if (getReportCallCount === failGetReportOnCall) {
-    return {error: 'Report is invalid (test override)'};
-  }
-  return realGetReport(...args);
-};
-util.getPageDataStrings = async (...args) => {
-  if (pageDataStringsOverride !== null) {
-    return pageDataStringsOverride;
+let pageDataStringsOverride: any = null;
+mock.module('../../util.ts', {
+  exports: {
+    ...realUtil,
+    getReport: async (...args: any[]) => {
+      getReportCallCount++;
+      if (getReportCallCount === failGetReportOnCall) {
+        return {error: 'Report is invalid (test override)'};
+      }
+      return (realUtil.getReport as any)(...args);
+    },
+    getPageDataStrings: async (...args: any[]) => {
+      if (pageDataStringsOverride !== null) {
+        return pageDataStringsOverride;
+      }
+      return (realUtil.getPageDataStrings as any)(...args);
+    }
   }
-  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(() => {
@@ -74,11 +77,14 @@ test('listViolators includes links to listDiagnoses for violators', async () =>
   assert.ok(diagnosisLinks.length > 0);
 });
 
-test('listViolators returns an error status for a hidden report', async () => {
-  const result = await answer('linkNoText/260101T0007/hid');
-  assert.equal(result.status, 'error');
+test('listViolators excludes cantTell instances from the violator count', async () => {
+  const result = await answer('focusIndicationBad/260101T0000/mix');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('0 violators were'));
+  assert.ok(!result.answerPage.includes('<h3>Element'));
 });
 
+
 test('listViolators returns an error status for a nonexistent report', async () => {
   const result = await answer('linkNoText/999999T9999/xyz');
   assert.equal(result.status, 'error');
@@ -103,7 +109,7 @@ test('listViolators returns an error when getReport fails after getPageDataStrin
 });
 
 test('listViolators includes take-me-there links for text-linkable violators', async () => {
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportsDir = path.join(dbDir, 'reports');
   const reportPath = path.join(reportsDir, '260101T0003-tlk.json');
   try {
@@ -184,7 +190,7 @@ test('listViolators handles instances with missing catalogIndex and acts with no
   // - An instance with no catalogIndex (covers || '0' on line 85)
   // - A catalog entry with no tagName (covers ?? pathID fallback on lines 87-88)
   // - Multiple violators (covers plural count on line 101)
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportPath = path.join(dbDir, 'reports', '260101T0004-nvi.json');
   const report = {
     id: '260101T0004-nvi',
@@ -257,9 +263,10 @@ test('listViolators handles instances with missing catalogIndex and acts with no
 
 test('listViolators uses HTML fallback when catalog has no tagName and pathID is missing', async () => {
   // Create a report where an instance has no pathID and the catalog
-  // entry has no tagName, so the ?? 'HTML' fallback is hit.
-  // Also uses a catalogIndex not in the catalog to cover || {} on line 144.
-  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  // entry has no tagName, so the ?? 'HTML' tagName fallback is hit.
+  // Also uses a catalogIndex not in the catalog, so catalogItem is undefined
+  // and catalogItem?.textLinkable is falsy (no take-me-there link is added).
+  const dbDir = (await import('../../test/dbFixture.ts')).fixtureDBDir;
   const reportPath = path.join(dbDir, 'reports', '260101T0005-htm.json');
   const report = {
     id: '260101T0005-htm',

package/web/manage/index.ts

@@ -0,0 +1,22 @@
+/*
+  index.ts
+  Lists the actions that managers can take.
+*/
+
+// IMPORTS
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// FUNCTIONS
+
+// Returns the answer page.
+export const answer = async (): Promise<{status: string; answerPage: string}> => {
+  // Get the answer page.
+  const answerPage = await fs.readFile(path.join(import.meta.dirname, 'index.html'), 'utf8');
+  // Return it.
+  return {
+    status: 'ok',
+    answerPage
+  };
+};

package/web/pruneReportsForm/index.ts

@@ -0,0 +1,18 @@
+/*
+  index.ts
+  Serves a form for deleting superseded reports.
+*/
+
+// IMPORTS
+
+import {reportDeletionForm} from '../reportDeletion.ts';
+
+// FUNCTIONS
+
+// Returns a form for deleting non-latest reports.
+export const answer = async (_: any, search: string) => reportDeletionForm(import.meta.dirname, search, {
+  intro: 'Choose the superseded reports to delete.',
+  emptyIntro: 'Each target has only 1 report, so there are no superseded reports to delete.',
+  failurePrefix: 'Deleting superseded reports failed',
+  isDeletable: (specs, index) => specs[index + 1]?.url === specs[index]?.url
+});

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

@@ -1,23 +1,23 @@
 /*
-  pruneReportsForm.test.js
-  Unit tests for web/pruneReportsForm/index.js.
+  pruneReportsForm.test.ts
+  Unit tests for web/pruneReportsForm/index.ts.
 */
 
 // IMPORTS
 
-const {test, before, after} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const fs = require('fs/promises');
-const {parse} = require('node-html-parser');
-const {answer} = require('./index');
-const {reportsPath} = require('../../util');
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'fs/promises';
+import {parse} from 'node-html-parser';
+import {answer} from './index.ts';
+import {reportsPath} from '../../util.ts';
 
 // SETUP AND TEARDOWN
 
 const savedAuthCode = process.env.AUTH_CODE;
 const savedDBDir = process.env.DB_DIR;
-const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+import {fixtureDBDir} from '../../test/dbFixture.ts';
 
 before(() => {
   process.env.AUTH_CODE = 'test-auth-code';
@@ -52,7 +52,7 @@ test('pruneReportsForm returns an error for an invalid auth code', async () => {
 test('pruneReportsForm returns an error when deleting a nonexistent report', async () => {
   const result = await answer(null, 'authCode=test-auth-code&report=999999T9999-nope');
   assert.equal(result.status, 'error');
-  assert.ok(result.message.includes('Deleting superseded reports'));
+  assert.ok(result.message?.includes('Deleting superseded reports'));
 });
 
 test('pruneReportsForm deletes a superseded report with valid auth code', async () => {

package/web/reannotate/index.ts

@@ -0,0 +1,71 @@
+/*
+  index.ts
+  Reannotates all available latest reports.
+*/
+
+// IMPORTS
+
+import {
+  annotateReportObject,
+  getJSON,
+  getReport,
+  getReportPath,
+  isReportError,
+  readdirOrCreate,
+  reportsPath
+} from '../../util.ts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// FUNCTIONS
+
+// Implements a reannotation order and returns an acknowledgement page.
+export const answer = async (authCode: string) => {
+  // If the authorization code is valid:
+  if (authCode === process.env.AUTH_CODE) {
+    // Get the names of the stored report files.
+    const reportFileNames = (await readdirOrCreate(reportsPath(), 'Reports directory'))
+    .filter(fileName => fileName.endsWith('.json'));
+    // If any exist:
+    if (reportFileNames.length) {
+      // For each report file:
+      for (const reportFileName of reportFileNames) {
+        const [timeStamp, jobID] = reportFileName.slice(0, -5).split('-') as [string, string];
+        // Get the report.
+        const report = await getReport(timeStamp, jobID);
+        // If this failed:
+        if (isReportError(report)) {
+          // Return an error page.
+          return {
+            status: 'error',
+            message: report.error
+          };
+        }
+        // Otherwise, i.e. if it succeeded, reannotate it in place.
+        await annotateReportObject(report);
+        // Save the reannotated report.
+        await fs.writeFile(getReportPath(timeStamp, jobID), getJSON(report));
+      }
+    }
+    // Otherwise, i.e. if it failed:
+    else {
+      // Return an error page.
+      return {
+        status: 'error',
+        message: 'Got data on no available reports'
+      };
+    }
+    // If every annotation succeeded, get the answer page.
+    const answerPage = await fs.readFile(path.join(import.meta.dirname, 'index.html'), 'utf8');
+    // Return it.
+    return {
+      status: 'ok',
+      answerPage
+    };
+  }
+  // Otherwise, i.e. if the authorization code is invalid, return an error page.
+  return {
+    status: 'error',
+    message: 'Invalid authorization code'
+  };
+};

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

@@ -1,20 +1,20 @@
 /*
-  reannotate.test.js
-  Unit tests for web/reannotate/index.js, covering the reannotation logic branches.
+  reannotate.test.ts
+  Unit tests for web/reannotate/index.ts, covering the reannotation logic branches.
 */
 
 // IMPORTS
 
-const {test, before, after, beforeEach} = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {parse} = require('node-html-parser');
+import {test, before, after, beforeEach} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {parse} from 'node-html-parser';
 
 // CONSTANTS
 
-const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+import {fixtureDBDir} from '../../test/dbFixture.ts';
 const reportsDir = path.join(fixtureDBDir, 'reports');
 
 // SETUP AND TEARDOWN
@@ -39,7 +39,7 @@ after(async () => {
 // Backs up all report files and returns a map of fileName to content.
 const backupReports = async () => {
   const reportFiles = await fs.readdir(reportsDir);
-  const backups = {};
+  const backups: Record<string, string> = {};
   for (const file of reportFiles) {
     backups[file] = await fs.readFile(path.join(reportsDir, file), 'utf8');
   }
@@ -47,7 +47,7 @@ const backupReports = async () => {
 };
 
 // Restores all report files from a backup map.
-const restoreReports = async backups => {
+const restoreReports = async (backups: Record<string, string>) => {
   for (const [file, content] of Object.entries(backups)) {
     await fs.writeFile(path.join(reportsDir, file), content);
   }
@@ -56,7 +56,7 @@ const restoreReports = async backups => {
 // TESTS
 
 test('answer returns an error for an invalid authorization code', async () => {
-  const {answer} = require('./index');
+  const {answer} = await import('./index.ts');
   const result = await answer('wrong-code');
   assert.equal(result.status, 'error');
   assert.equal(result.message, 'Invalid authorization code');
@@ -70,8 +70,7 @@ test('answer returns an error when no reports are available', async () => {
   process.env.DB_DIR = tempDir;
   try {
     // Re-require the module so it picks up the new DB_DIR.
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
+    const {answer} = await import('./index.ts');
     const result = await answer('test-auth-code');
     assert.equal(result.status, 'error');
     assert.equal(result.message, 'Got data on no available reports');
@@ -88,7 +87,7 @@ test('answer returns an error when no reports are available', async () => {
 });
 
 test('answer returns an error when a report fails annotation', {timeout: 2000}, async () => {
-  // Back up all fixture reports, because annotateReport modifies good reports
+  // Back up all fixture reports, because reannotation modifies good reports
   // in place before it reaches the bad one and returns an error.
   const backups = await backupReports();
   // Create a temporary report file that passes getReportExtract but fails
@@ -104,11 +103,10 @@ test('answer returns an error when a report fails annotation', {timeout: 2000},
   };
   await fs.writeFile(badReportPath, JSON.stringify(badReport));
   try {
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
+    const {answer} = await import('./index.ts');
     const result = await answer('test-auth-code');
     assert.equal(result.status, 'error');
-    assert.ok(result.message.includes('invalid'), `Expected message about invalid report, got: ${result.message}`);
+    assert.ok(result.message?.includes('not usable'), `Expected message about unusable report, got: ${result.message}`);
   }
   finally {
     try {
@@ -117,17 +115,16 @@ test('answer returns an error when a report fails annotation', {timeout: 2000},
     catch {
       // Ignore cleanup errors for the temporary bad report.
     }
-    // Restore all fixture reports modified by annotateReport.
+    // Restore all fixture reports modified by reannotation.
     await restoreReports(backups);
   }
 });
 
 test('answer returns ok with an answer page when all reports annotate successfully', {timeout: 2000}, async () => {
-  // Back up all fixture reports, because annotateReport modifies them in place.
+  // Back up all fixture reports, because reannotation modifies them in place.
   const backups = await backupReports();
   try {
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
+    const {answer} = await import('./index.ts');
     const result = await answer('test-auth-code');
     assert.equal(result.status, 'ok');
     assert.ok(result.answerPage, 'answerPage should be present');

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

@@ -1,21 +1,21 @@
 /*
-  index.js
+  index.ts
   Serves a form to reannotate reports.
 */
 
 // IMPORTS
 
-const {getIssue, getReport, getReportExtracts} = require('../../util');
-const fs = require('fs/promises');
-const path = require('path');
+import {
+  getIssue, getReport, getReportExtracts, getTestActInstances, isReportError, populateTemplate
+} from '../../util.ts';
 
 // FUNCTIONS
 
 // Adds parameters to a query for the answer page.
-const populateQuery = async query => {
+const populateQuery = async (query: Record<string, any>) => {
   // Initialize data on rule classification.
-  const reClassified = {};
-  const stillUnclassified = {};
+  const reClassified: Record<string, Record<string, Set<string>>> = {};
+  const stillUnclassified: Record<string, Record<string, Set<string>>> = {};
   // Get an extract of all available reports.
   const reportExtracts = await getReportExtracts();
   // For each report:
@@ -23,50 +23,45 @@ const populateQuery = async query => {
     const {jobID, timeStamp} = reportExtract;
     // Get it.
     const report = await getReport(timeStamp, jobID);
-    const {acts = [], error, id} = report;
     // If this failed:
-    if (error) {
+    if (isReportError(report)) {
       // Populate the query with the reason.
-      query.error = error;
+      query.error = report.error;
       // Stop populating the query.
       return;
     }
-    // Otherwise, i.e. if it succeeded, for each act in the report:
-    acts.forEach(act => {
-      const {result, type, which} = act;
-      // If it is a test act with standard instances:
-      if (type === 'test' && result?.standardResult?.instances?.length) {
-        // For each standard instance:
-        result.standardResult.instances.forEach(instance => {
-          const {ruleID} = instance;
-          // Get the issue ID of the rule, or null if none.
-          const issueID = getIssue(which, ruleID);
-          // If the issue ID of the instance differs from that of the rule:
-          if ((instance.issueID || null) !== issueID) {
-            // Add the rule and the report to the rules with changed issue IDs.
-            reClassified[which] ??= {};
-            reClassified[which][ruleID] ??= new Set();
-            reClassified[which][ruleID].add(id);
-          }
-          // Otherwise, if the instance and the rule both have no issue ID:
-          else if (!issueID){
-            // Add the rule and the report to the rules that are still unclassified.
-            stillUnclassified[which] ??= {};
-            stillUnclassified[which][ruleID] ??= new Set();
-            stillUnclassified[which][ruleID].add(id);
-          }
-        });
+    const id = report.id as string;
+    // Otherwise, i.e. if it succeeded, for each standard instance of each test act
+    // (all outcomes, including cantTell — classification maps rules to issues regardless of outcome):
+    getTestActInstances(report).forEach(({act, instance}) => {
+      const {ruleID} = instance;
+      const which = act.which!;
+      // Get the issue ID of the rule, or null if none.
+      const issueID = getIssue(which, ruleID);
+      // If the issue ID of the instance differs from that of the rule:
+      if ((instance.issueID || null) !== issueID) {
+        // Add the rule and the report to the rules with changed issue IDs.
+        reClassified[which] ??= {};
+        reClassified[which][ruleID] ??= new Set();
+        reClassified[which][ruleID].add(id);
+      }
+      // Otherwise, if the instance and the rule both have no issue ID:
+      else if (!issueID){
+        // Add the rule and the report to the rules that are still unclassified.
+        stillUnclassified[which] ??= {};
+        stillUnclassified[which][ruleID] ??= new Set();
+        stillUnclassified[which][ruleID].add(id);
       }
     });
   };
-  const stillUnclassifiedLines = [];
-  const reClassifiedLines = [];
+  const stillUnclassifiedLines: string[] = [];
+  const reClassifiedLines: string[] = [];
   const margin = ' '.repeat(6);
   // For each rule engine reporting any violations of still unclassified rules:
   Object.keys(stillUnclassified).forEach(engineID => {
     // For each such rule:
-    Object.keys(stillUnclassified[engineID]).forEach(ruleID => {
-      const reportIDs = Array.from(stillUnclassified[engineID][ruleID]);
+    Object.keys(stillUnclassified[engineID]!).forEach(ruleID => {
+      const reportIDs = Array.from(stillUnclassified[engineID]![ruleID]!);
       // Add a line to the lines on the rule.
       stillUnclassifiedLines.push(
         `${margin}<li>${engineID}: ${ruleID} (${reportIDs.join(', ')})</li>`
@@ -78,8 +73,8 @@ const populateQuery = async query => {
   // For each rule engine reporting any discrepancies in rule classification:
   Object.keys(reClassified).forEach(engineID => {
     // For each such rule:
-    Object.keys(reClassified[engineID]).forEach(ruleID => {
-      const reportIDs = Array.from(reClassified[engineID][ruleID]);
+    Object.keys(reClassified[engineID]!).forEach(ruleID => {
+      const reportIDs = Array.from(reClassified[engineID]![ruleID]!);
       // Add a line to the lines on the rule.
       reClassifiedLines.push(
         `${margin}<li>${engineID}: ${ruleID} (${reportIDs.join(', ')})</li>`
@@ -88,7 +83,7 @@ const populateQuery = async query => {
   });
   // Add the lines to the query.
   query.reClassified = reClassifiedLines.join('\n');
-  const formLines = [];
+  const formLines: string[] = [];
   if (reClassifiedLines.length) {
     query.how = 'Each <q>reclassified</q> rule indicates that report annotations are out of date. To update them, submit your authorization code.';
   }
@@ -104,8 +99,8 @@ const populateQuery = async query => {
   query.reannotateForm = formLines.join('\n');
 };
 // Returns a page disclosing newly classified rules and a form to reannotate reports.
-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:
@@ -116,12 +111,8 @@ exports.answer = async () => {
       message: query.error
     };
   }
-  // Otherwise, i.e. if the query 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]);
-  });
+  // Otherwise, i.e. if the query does not report an error, get the populated template.
+  const answerPage = await populateTemplate(import.meta.dirname, query);
   // Return the populated page.
   return {
     status: 'ok',

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

@@ -1,21 +1,21 @@
 /*
-  reannotateForm.test.js
-  Unit tests for web/reannotateForm/index.js, covering error, no-reclassified,
+  reannotateForm.test.ts
+  Unit tests for web/reannotateForm/index.ts, covering error, no-reclassified,
   and success branches of answer and populateQuery.
 */
 
 // IMPORTS
 
-const {test, before, after, beforeEach} = require('node:test');
-const assert = require('node:assert/strict');
-const fs = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const {parse} = require('node-html-parser');
+import {test, before, after, beforeEach} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {parse} from 'node-html-parser';
 
 // CONSTANTS
 
-const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+import {fixtureDBDir} from '../../test/dbFixture.ts';
 const reportsDir = path.join(fixtureDBDir, 'reports');
 const emptyReportName = '260101T0005-emp.json';
 
@@ -41,8 +41,7 @@ after(async () => {
 test('answer returns ok with reclassified rules listed in the page', async () => {
   // The fixture reports have instances whose issueIDs differ from the
   // current rule specs, so reclassified rules should be listed.
-  delete require.cache[require.resolve('./index')];
-  const {answer} = require('./index');
+  const {answer} = await import('./index.ts');
   const result = await answer();
   assert.equal(result.status, 'ok');
   assert.ok(result.answerPage, 'answerPage should be present');
@@ -75,8 +74,7 @@ test('answer returns ok with no-reclassified message when reports have no violat
   const originalDBDir = process.env.DB_DIR;
   process.env.DB_DIR = tempDir;
   try {
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
+    const {answer} = await import('./index.ts');
     const result = await answer();
     assert.equal(result.status, 'ok');
     assert.ok(result.answerPage, 'answerPage should be present');
@@ -117,11 +115,10 @@ test('answer returns an error when a report fails to load', async () => {
   };
   await fs.writeFile(badReportPath, JSON.stringify(badReport));
   try {
-    delete require.cache[require.resolve('./index')];
-    const {answer} = require('./index');
+    const {answer} = await import('./index.ts');
     const result = await answer();
     assert.equal(result.status, 'error');
-    assert.ok(result.message.includes('invalid'), `Expected message about invalid report, got: ${result.message}`);
+    assert.ok(result.message.includes('not usable'), `Expected message about unusable report, got: ${result.message}`);
   }
   finally {
     try {