@jrpool/kilotest 46.0.4 → 46.0.6

package/api/getReport.test.js

@@ -0,0 +1,62 @@
+/*
+  getReport.test.js
+  Tests for api/getReport.js 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('./getReport');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('getReport returns the full report for a valid report', async () => {
+  const body = await response(['260101T0000', 'mix']);
+  const content = body['response content'];
+  assert.equal(typeof content['size of the report in bytes'], 'number');
+  assert.ok(content['size of the report in bytes'] > 0);
+  const report = content['full report'];
+  assert.equal(report.id, '260101T0000-mix');
+  assert.equal(report.target.what, 'Mixed Outcomes Page');
+  assert.equal(report.target.url, 'https://example.com/mixed');
+  assert.equal(report.acts.length, 2);
+});
+
+test('getReport returns an error for a nonexistent report', async () => {
+  const body = await response(['999999T9999', 'xyz']);
+  const content = body['response content'];
+  assert.equal(content['full report'], null);
+  assert.equal(typeof content['size of the report in bytes'], 'string');
+});
+
+test('getReport returns an error for the hidden report', async () => {
+  const body = await response(['260101T0007', 'hid']);
+  const content = body['response content'];
+  assert.equal(content['full report'], null);
+  assert.equal(typeof content['size of the report in bytes'], 'string');
+});
+
+test('getReport includes tool name and metadata', async () => {
+  const body = await response(['260101T0000', 'mix']);
+  assert.equal(body['tool name'], 'getReport');
+  assert.ok(body['response metadata'].identifier);
+});

package/api/listDiagnoses.test.js

@@ -0,0 +1,88 @@
+/*
+  listDiagnoses.test.js
+  Tests for api/listDiagnoses.js 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('./listDiagnoses');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('listDiagnoses returns 2 diagnoses for catalogIndex 0, linkNoText, in the mixed report (axe and alfa, excluding cantTell)', async () => {
+  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'];
+  assert.equal(diagnoses.length, 2);
+  const rules = diagnoses.map(d => d['identifier of the violated rule']).sort();
+  assert.deepEqual(rules, ['r11', 'r11']);
+  const descriptions = diagnoses.map(d => d['description of the violation']);
+  assert.ok(descriptions.every(d => d === 'The link does not have an accessible name'));
+});
+
+test('listDiagnoses returns 0 diagnoses when all instances are cantTell', async () => {
+  const body = await response(['0', 'focusIndicationBad', '260101T0001', 'ct']);
+  const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'];
+  assert.equal(diagnoses.length, 0);
+});
+
+test('listDiagnoses treats missing outcome as a violation', async () => {
+  const body = await response(['0', 'linkNoText', '260101T0002', 'no']);
+  const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'];
+  assert.equal(diagnoses.length, 1);
+  assert.equal(diagnoses[0]['description of the violation'], 'Button has no accessible name');
+  assert.equal(diagnoses[0]['severity of the violation on a 0-to-3 scale'], 3);
+});
+
+test('listDiagnoses returns element basics from the catalog', async () => {
+  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const elementBasics = body['response content']['basics about the element'];
+  assert.equal(elementBasics.identifier, '0');
+  assert.equal(elementBasics['tag name'], 'A');
+  assert.equal(elementBasics['inner text'], 'About Us');
+});
+
+test('listDiagnoses returns element details from the catalog', async () => {
+  const body = await response(['0', 'linkNoText', '260101T0000', 'mix']);
+  const elementDetails = body['response content']['details about the element'];
+  assert.equal(elementDetails['start tag'], '<a>');
+  assert.equal(elementDetails['XPath'], '/html/body/a[1]');
+  assert.equal(elementDetails['x, y, width, and height of bounding box'], '10:20:80:30');
+});
+
+test('listDiagnoses returns an error for an unknown issue ID', async () => {
+  const body = await response(['0', 'nonexistentIssue', '260101T0000', 'mix']);
+  const basics = body['response content']['basics about the issue'];
+  assert.ok(basics.error);
+});
+
+test('listDiagnoses returns an error for a nonexistent catalog index', async () => {
+  const body = await response(['999', 'linkNoText', '260101T0000', 'mix']);
+  const basics = body['response content']['basics about the element'];
+  assert.ok(basics.error);
+});
+
+test('listDiagnoses returns an error for a nonexistent report', async () => {
+  const body = await response(['0', 'linkNoText', '999999T9999', 'xyz']);
+  const basics = body['response content']['basics about the report'];
+  assert.ok(basics.error);
+});

package/api/listIssues.test.js

@@ -0,0 +1,98 @@
+/*
+  listIssues.test.js
+  Tests for api/listIssues.js 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');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+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.equal(issues.length, 2);
+  const summaries = issues.map(i => 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.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.equal(issues.length, 1);
+  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.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 preventions = details['test results']['rule engines that could not test the page'];
+  assert.equal(preventions.length, 1);
+  assert.equal(preventions[0].name, 'Alfa');
+  assert.equal(preventions[0]['reason for failure'], 'page timed out');
+});
+
+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'];
+  const linkIssue = issues.find(i => i.identifier === 'linkNoText');
+  assert.deepEqual(linkIssue['rule engines with any violations belonging to the issue'], ['Alfa', 'Axe']);
+  const allCapsIssue = issues.find(i => i.identifier === 'allCaps');
+  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 counts = details['test results']['counts of issues by priority'];
+  // linkNoText weight 4 (highest), allCaps weight 1 (lowest).
+  assert.equal(counts.highest, 1);
+  assert.equal(counts.high, 0);
+  assert.equal(counts.low, 0);
+  assert.equal(counts.lowest, 1);
+});
+
+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'];
+  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'];
+  assert.ok(basics.error);
+});

package/api/listReports.test.js

@@ -0,0 +1,104 @@
+/*
+  listReports.test.js
+  Tests for api/listReports.js 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');
+
+// CONSTANTS
+
+// Fixture report identifiers in the reports/ directory (excluding the hidden one).
+const fixtureIds = [
+  ['260101T0000', 'mix'],
+  ['260101T0001', 'ct'],
+  ['260101T0002', 'no'],
+  ['260101T0005', 'emp'],
+  ['260101T0006', 'prv'],
+  ['260202T0000', 'new']
+];
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('listReports returns basics about all 6 non-hidden reports', async () => {
+  const body = await response();
+  const reportsBasics = body['response content']['basics about all available reports'];
+  assert.equal(reportsBasics.length, 6);
+  const ids = reportsBasics.map(b => b.identifier).sort();
+  const expectedIds = fixtureIds.map(([ts, jid]) => `${ts}-${jid}`).sort();
+  assert.deepEqual(ids, expectedIds);
+});
+
+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);
+  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);
+  // All CantTell Page, Empty Results Page, Mixed Outcomes Page, Mixed Outcomes Page, No Outcomes Page, Prevented Page.
+  assert.deepEqual(
+    descriptions,
+    [
+      'All CantTell Page',
+      'Empty Results Page',
+      'Mixed Outcomes Page',
+      'Mixed Outcomes Page',
+      'No Outcomes Page',
+      'Prevented Page'
+    ]
+  );
+  // 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');
+});
+
+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');
+  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);
+});
+
+test('listReports includes request-test instructions', async () => {
+  const body = await response();
+  const content = body['response content'];
+  assert.ok(content['how to request that a page with no report be tested']);
+  assert.ok(content['how a web user can request that the page be tested']);
+  assert.equal(content['how to request that a page with no report be tested'].method, 'POST');
+});
+
+test('listReports includes tool name and metadata', async () => {
+  const body = await response();
+  assert.equal(body['tool name'], 'listReports');
+  assert.ok(body['response metadata'].identifier);
+  assert.ok(body['response metadata']['date and time']);
+});

package/api/listViolators.test.js

@@ -0,0 +1,73 @@
+/*
+  listViolators.test.js
+  Tests for api/listViolators.js 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('./listViolators');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('listViolators returns 1 violator for linkNoText in the mixed report, excluding cantTell', async () => {
+  const body = await response(['linkNoText', '260101T0000', 'mix']);
+  const violators = body['response content']['basics about all elements exhibiting the issue'];
+  assert.equal(violators.length, 1);
+  assert.equal(violators[0].identifier, '0');
+  assert.equal(violators[0]['tag name'], 'A');
+  assert.equal(violators[0]['inner text'], 'About Us');
+  assert.equal(violators[0]['count of rule engines reporting that the element exhibited the issue'], 2);
+});
+
+test('listViolators returns 0 violators for an issue when all instances are cantTell', async () => {
+  const body = await response(['focusIndicationBad', '260101T0001', 'ct']);
+  const violators = body['response content']['basics about all elements exhibiting the issue'];
+  assert.equal(violators.length, 0);
+});
+
+test('listViolators treats missing outcome as a violation', async () => {
+  const body = await response(['linkNoText', '260101T0002', 'no']);
+  const violators = body['response content']['basics about all elements exhibiting the issue'];
+  assert.equal(violators.length, 1);
+  assert.equal(violators[0].identifier, '0');
+});
+
+test('listViolators returns an error for an unknown issue ID', async () => {
+  const body = await response(['nonexistentIssue', '260101T0000', 'mix']);
+  const basics = body['response content']['basics about the issue'];
+  assert.ok(basics.error);
+});
+
+test('listViolators returns an error for a nonexistent report', async () => {
+  const body = await response(['linkNoText', '999999T9999', 'xyz']);
+  const basics = body['response content']['basics about the report'];
+  assert.ok(basics.error);
+});
+
+test('listViolators includes reporter facts for the issue', async () => {
+  const body = await response(['linkNoText', '260101T0000', 'mix']);
+  const details = body['response content']['details about the issue'];
+  const reporters = details['rule engines reporting violations belonging to the issue'];
+  const names = reporters.map(r => r.name).sort();
+  assert.deepEqual(names, ['Alfa', 'Axe']);
+});

package/api/requestFeature.test.js

@@ -0,0 +1,54 @@
+/*
+  requestFeature.test.js
+  Tests for api/requestFeature.js with mocked side effects.
+*/
+
+// IMPORTS
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const alerts = require('../alerts');
+
+// SETUP AND TEARDOWN
+
+let sendAlertCalls = [];
+
+before(() => {
+  sendAlertCalls = [];
+  // @ts-expect-error: Replacing the real function with a mock for testing.
+  alerts.sendAlert = async (subject, body) => {
+    sendAlertCalls.push({subject, body});
+  };
+});
+
+// Require requestFeature after the mock is in place, so it captures the mocked sendAlert.
+const {response} = require('./requestFeature');
+
+after(() => {
+});
+
+// TESTS
+
+test('requestFeature rejects an empty feature request', async () => {
+  const body = await response(['']);
+  const details = body['response content']['details about your request'];
+  assert.ok(details.error);
+  assert.equal(sendAlertCalls.length, 0);
+});
+
+test('requestFeature accepts a non-empty feature request and notifies the manager', async () => {
+  const body = await response(['Add a dark mode toggle']);
+  const details = body['response content']['details about your request'];
+  assert.equal(details.error, undefined);
+  assert.ok(details['date and time received']);
+  assert.equal(details.disposition, 'received and logged; manager notified');
+  assert.equal(sendAlertCalls.length, 1);
+  assert.equal(sendAlertCalls[0].subject, 'MCP feature request received');
+  assert.equal(sendAlertCalls[0].body, 'Add a dark mode toggle');
+});
+
+test('requestFeature includes tool name and metadata', async () => {
+  const body = await response(['Some feature']);
+  assert.equal(body['tool name'], 'requestFeature');
+  assert.ok(body['response metadata'].identifier);
+});

package/api/requestRetest.js

@@ -6,7 +6,7 @@
 // IMPORTS
 
 const {getResponseMetadata, getToolsFacts, processTestRequest, thisHost} = require('./util');
-const {getLatestReportExtracts, getReportsExtract} = require('../util');
+const {getLatestReportExtracts, getReportExtract} = require('../util');
 
 // FUNCTIONS
 
@@ -19,15 +19,11 @@ exports.response = async args => {
     'disposition of your request': null
   };
   const reasonLength = reason.length;
-  // Get data on the available reports.
-  const reportsExtract = await getReportsExtract();
   // Get data on the report.
-  const reportExtract = Object
-  .values(reportsExtract)
-  .find(extract => extract.timeStamp === timeStamp && extract.jobID === jobID);
-  const {what, url} = reportExtract || {};
+  const reportExtract = await getReportExtract(timeStamp, jobID);
+  const {what, url} = reportExtract.error ? {} : reportExtract;
   // If this failed:
-  if (!reportExtract) {
+  if (reportExtract.error) {
     // Add this to the response content.
     responseContent['details about your request'] = {
       error: 'request invalid: the specified existing report is not an available report'

package/api/requestRetest.test.js

@@ -0,0 +1,76 @@
+/*
+  requestRetest.test.js
+  Tests for api/requestRetest.js using the fixture corpus, with mocked side effects.
+*/
+
+// IMPORTS
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const apiUtil = require('./util');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+let processTestRequestCalls = [];
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+  processTestRequestCalls = [];
+  // @ts-expect-error: Replacing the real function with a mock for testing.
+  apiUtil.processTestRequest = async (testType, what, url, reason) => {
+    processTestRequestCalls.push({testType, what, url, reason});
+  };
+});
+
+// Require requestRetest after the mock is in place, so it captures the mocked processTestRequest.
+const {response} = require('./requestRetest');
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('requestRetest rejects a nonexistent report', async () => {
+  const body = await response(['999999T9999', 'xyz', 'A reason that is long enough.']);
+  assert.ok(body['response content']['details about your request'].error);
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestRetest rejects a superseded report', async () => {
+  const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
+  const details = body['response content']['details about your request'];
+  assert.ok(details.error.includes('later report'));
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestRetest rejects a reason shorter than 20 characters', async () => {
+  const body = await response(['260101T0001', 'ct', 'short']);
+  const details = body['response content']['details about your request'];
+  assert.ok(details.error.includes('reason'));
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestRetest rejects a reason longer than 100 characters', async () => {
+  const longReason = 'x'.repeat(101);
+  const body = await response(['260101T0001', 'ct', longReason]);
+  const details = body['response content']['details about your request'];
+  assert.ok(details.error.includes('reason'));
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestRetest accepts a valid retest request for the latest report of a page', async () => {
+  const body = await response(['260202T0000', 'new', 'A reason that is long enough.']);
+  const details = body['response content']['details about your request'];
+  assert.equal(details.error, undefined);
+  assert.equal(details['page to be retested'].description, 'Mixed Outcomes Page');
+  assert.equal(processTestRequestCalls.length, 1);
+  assert.equal(processTestRequestCalls[0].testType, 'retest');
+});

package/api/requestTest.test.js

@@ -0,0 +1,81 @@
+/*
+  requestTest.test.js
+  Tests for api/requestTest.js using the fixture corpus, with mocked side effects.
+*/
+
+// IMPORTS
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const apiUtil = require('./util');
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+let processTestRequestCalls = [];
+
+before(() => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+  processTestRequestCalls = [];
+  // @ts-expect-error: Replacing the real function with a mock for testing.
+  apiUtil.processTestRequest = async (testType, what, url, reason) => {
+    processTestRequestCalls.push({testType, what, url, reason});
+  };
+});
+
+// Require requestTest after the mock is in place, so it captures the mocked processTestRequest.
+const {response} = require('./requestTest');
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('requestTest rejects an empty description', async () => {
+  const body = await response(['', 'https://example.com/test', 'A reason that is long enough.']);
+  assert.ok(body['response content']['details about your request'].error);
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestTest rejects a description longer than 100 characters', async () => {
+  const longWhat = 'x'.repeat(101);
+  const body = await response([longWhat, 'https://example.com/test', 'A reason that is long enough.']);
+  assert.ok(body['response content']['details about your request'].error);
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestTest rejects a URL shorter than 12 characters', async () => {
+  const body = await response(['Test Page', 'short', 'A reason that is long enough.']);
+  assert.ok(body['response content']['details about your request'].error);
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestTest rejects an already-tested page', async () => {
+  const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
+  const details = body['response content']['details about your request'];
+  assert.ok(details.error.includes('already been tested'));
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
+test('requestTest accepts a valid new page request', async () => {
+  const body = await response(['Brand New Page', 'https://example.com/brandnew', 'A reason that is long enough.']);
+  const details = body['response content']['details about your request'];
+  assert.equal(details.error, undefined);
+  assert.equal(details['page to be tested'].description, 'Brand New Page');
+  assert.equal(processTestRequestCalls.length, 1);
+  assert.equal(processTestRequestCalls[0].testType, 'test');
+});
+
+test('requestTest includes disposition information for a valid request', async () => {
+  const body = await response(['Brand New Page', 'https://example.com/brandnew', 'A reason that is long enough.']);
+  const disposition = body['response content']['disposition of your request'];
+  assert.ok(disposition);
+  assert.ok(disposition['what happens next']);
+});

package/index.js

@@ -24,7 +24,6 @@ const {
   isTimeStamp,
   isJobID,
   jobsPath,
-  makeReportsExtract,
   recsLock,
   reportsPath
 } = require('./util');
@@ -747,8 +746,6 @@ const requestHandler = async (request, response) => {
                 report.sources = {...report.sources, worker: workerName};
                 // Save the report.
                 await fs.writeFile(getReportPath(timeStamp, jobID), getJSON(report));
-                // Update the data on the available reports.
-                await makeReportsExtract();
                 // Annotate the report.
                 await annotateReport(timeStamp, jobID);
                 console.log(`Testaro report ${id} was annotated, saved, and indexed`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jrpool/kilotest",
-  "version": "46.0.4",
+  "version": "46.0.6",
   "description": "Ensemble testing for front-end web quality",
   "main": "index.js",
   "engines": {

package/test/fixtures/buildFixtures.js

@@ -216,7 +216,7 @@ const main = async () => {
     preventedReport
   );
 
-  // Fixture 7: hidden. A report placed in hiddenReports/ instead of reports/, so it must not appear in listReports, listIssues, listViolators, listDiagnoses, or getReport API responses. The reportsExtract must not include it.
+  // Fixture 7: hidden. A report placed in hiddenReports/ instead of reports/, so it must not appear in listReports, listIssues, listViolators, listDiagnoses, or getReport API responses.
   const hiddenCatalog = {
     '0': catalogItem('A', 'Secret link', '/html/body/a[1]', '5:10:60:20')
   };

package/util.js

@@ -24,8 +24,6 @@ const recsPath = exports.recsPath = () => path.join(jobsPath(), 'recs.json');
 const reportsPath = exports.reportsPath = () => path.join(dbPath(), 'reports');
 // Path of the hidden-reports directory.
 const hiddenReportsPath = exports.hiddenReportsPath = () => path.join(dbPath(), 'hiddenReports');
-// Path of the reports data file.
-const reportsExtractPath = exports.reportsExtractPath = () => path.join(dbPath(), 'reportsExtract.json');
 // IDs, names, and sponsors of Testaro rule engines.
 const ruleEngines = exports.ruleEngines = {
   alfa: ['Alfa', 'Siteimprove'],
@@ -643,11 +641,11 @@ exports.getPageDataStrings = async (timeStamp, jobID, pageData) => {
 };
 // Returns the creation time and size of a report.
 const getReportStats = exports.getReportStats = async (timeStamp, jobID) => {
-  const reportStat = await fs.stat(
-    path.join(reportsPath(), `${timeStamp}-${jobID}.json`),
-    {throwIfNoEntry: false}
-  );
-  if (!reportStat) {
+  let reportStat;
+  try {
+    reportStat = await fs.stat(path.join(reportsPath(), `${timeStamp}-${jobID}.json`));
+  }
+  catch {
     return null;
   }
   const reportTime = reportStat.birthtime;
@@ -662,68 +660,43 @@ exports.isHidden = async (timeStamp, jobID) => {
   // Return whether the report is among them.
   return hiddenReportFileNames.includes(`${timeStamp}-${jobID}.json`);
 };
-// Creates, saves, and returns an extract of all available reports.
-const makeReportsExtract = exports.makeReportsExtract = async () => {
-  // Initialize the reports data.
-  const reportsExtract = {};
-  // Get the names of all report files.
-  const reportFileNames = await fs.readdir(reportsPath());
-  // For each of them:
-  for (const reportFileName of reportFileNames) {
-    // Get its content.
-    const reportJSON = await fs.readFile(path.join(reportsPath(), reportFileName), 'utf8');
-    // Get the object that it represents.
+// Returns an extract of an available report, or an error object if it cannot be read or parsed.
+const getReportExtract = exports.getReportExtract = async (timeStamp, jobID) => {
+  try {
+    const reportJSON = await fs.readFile(
+      path.join(reportsPath(), `${timeStamp}-${jobID}.json`), 'utf8'
+    );
     const report = JSON.parse(reportJSON);
     const {target, jobData} = report;
-    const jobName = reportFileName.slice(0, -5);
-    const [timeStamp, jobID] = jobName.split('-');
     const {what, url} = target;
-    // Get an extract from it.
-    const reportExtract = {
+    return {
       timeStamp,
       jobID,
       what,
       url,
       reportTime: new Date(`20${jobData.endTime}Z`).toISOString()
     };
-    // Add the report extract to the reports extract.
-    reportsExtract[jobName] = reportExtract;
-  }
-  // Ensure the data directory exists.
-  await fs.mkdir(dbPath(), {recursive: true});
-  // Save the extract of the reports.
-  await fs.writeFile(reportsExtractPath(), getJSON(reportsExtract));
-  // Return it.
-  return reportsExtract;
-};
-// Gets an extract of all available reports.
-const getReportsExtract = exports.getReportsExtract = async () => {
-  let reportsExtract;
-  try {
-    // Get the reports extract file.
-    const reportsExtractJSON = await fs.readFile(reportsExtractPath(), 'utf8');
-    // Get its data.
-    reportsExtract = JSON.parse(reportsExtractJSON);
-    // If it is empty:
-    if (!Object.keys(reportsExtract).length) {
-      // Throw an error.
-      throw new Error('Reports extract file is empty');
-    }
   }
-  // If this fails:
   catch {
-    // Create or recreate and get the reports extract.
-    reportsExtract = await makeReportsExtract();
+    return {
+      error: `No report ${timeStamp}-${jobID} is available`
+    };
   }
-  // Return the extract.
-  return reportsExtract;
 };
 // Returns extracts of all available reports.
 const getReportExtracts = exports.getReportExtracts = async () => {
-  const reportsExtract = await getReportsExtract();
-  return Object.values(reportsExtract);
+  const reportFileNames = await fs.readdir(reportsPath());
+  const extracts = [];
+  for (const reportFileName of reportFileNames) {
+    const [timeStamp, jobID] = reportFileName.slice(0, -5).split('-');
+    const extract = await getReportExtract(timeStamp, jobID);
+    if (!extract.error) {
+      extracts.push(extract);
+    }
+  }
+  return extracts;
 };
-// Returns whether a report is available on a page with a description or URL.
+// Returns whether a report with a description or URL is available.
 exports.isReportAvailable = async (what, url) => {
   const reportExtracts = await getReportExtracts();
   const whats = reportExtracts.map(reportExtract => reportExtract.what);
@@ -732,43 +705,19 @@ exports.isReportAvailable = async (what, url) => {
 };
 // Gets extracts of the latest available reports for all page descriptions.
 exports.getLatestReportExtracts = async () => {
-  // Get extracts of all available reports.
   const reportExtracts = await getReportExtracts();
-  // Sort them primarily by page description and secondarily by completion time.
   objectSort(reportExtracts, 'reportTime', 'alpha');
   objectSort(reportExtracts, 'what', 'alpha');
-  // Get the latest ones for all page descriptions.
   const latestReportExtracts = reportExtracts
   .filter((extract, index) => extract.what !== reportExtracts[index + 1]?.what);
-  // Return them.
   return latestReportExtracts;
 };
-// Returns an extract of an available report.
-exports.getReportExtract = async (timeStamp, jobID) => {
-  // Get the extract of all available reports.
-  const reportsExtract = await getReportsExtract();
-  // Get the extract of the report from it.
-  const reportExtract = reportsExtract[`${timeStamp}-${jobID}`];
-  // If it exists:
-  if (reportExtract) {
-    // Return it.
-    return reportExtract;
-  }
-  // Otherwise, i.e. if it does not exist, return this.
-  return {
-    error: `No report ${timeStamp}-${jobID} is available`
-  };
-};
 // Gets the descriptions of multi-report pages.
 exports.getMultiReportWhats = async () => {
-  // Get extracts of all available reports.
   const reportExtracts = await getReportExtracts();
-  // Get their sorted page descriptions.
   const sortedWhats = reportExtracts.map(extract => extract.what).sort();
-  // Get those that at least 2 reports have.
   const multiReportWhats = sortedWhats.filter(
     (what, index) => what !== sortedWhats[index - 1] && what === sortedWhats[index + 1]
   );
-  // Return an array of descriptions of multi-report pages.
   return multiReportWhats;
 };

package/util.test.js

@@ -13,8 +13,7 @@ const {
   jobsPath,
   recsPath,
   reportsPath,
-  hiddenReportsPath,
-  reportsExtractPath
+  hiddenReportsPath
 } = require('./util');
 
 // TESTS
@@ -48,7 +47,7 @@ test('dbPath honors DB_DIR when it is set', () => {
   }
 });
 
-test('jobsPath, recsPath, reportsPath, hiddenReportsPath, and reportsExtractPath derive from DB_DIR', () => {
+test('jobsPath, recsPath, reportsPath, and hiddenReportsPath derive from DB_DIR', () => {
   const saved = process.env.DB_DIR;
   process.env.DB_DIR = '/tmp/kilotest-fixtures';
   try {
@@ -56,7 +55,6 @@ test('jobsPath, recsPath, reportsPath, hiddenReportsPath, and reportsExtractPath
     assert.equal(recsPath(), path.join('/tmp/kilotest-fixtures', 'jobs', 'recs.json'));
     assert.equal(reportsPath(), path.join('/tmp/kilotest-fixtures', 'reports'));
     assert.equal(hiddenReportsPath(), path.join('/tmp/kilotest-fixtures', 'hiddenReports'));
-    assert.equal(reportsExtractPath(), path.join('/tmp/kilotest-fixtures', 'reportsExtract.json'));
   }
   finally {
     if (saved !== undefined) {

package/web/expungeReportsForm/index.js

@@ -5,7 +5,7 @@
 
 // IMPORTS
 
-const {getReportData, makeReportsExtract, objectSort, reportsPath} = require('../../util');
+const {getReportData, objectSort, reportsPath} = require('../../util');
 const fs = require('fs/promises');
 const path = require('path');
 
@@ -26,8 +26,6 @@ exports.answer = async (_, search) => {
           // Delete it.
           await fs.unlink(path.join(reportsPath(), `${jobName}.json`));
         }
-        // Update the extract of the available reports.
-        await makeReportsExtract();
       }
       // If this failed:
       catch (error) {

package/web/hideReportForm/index.js

@@ -5,7 +5,7 @@
 
 // IMPORTS
 
-const {getReportExtracts, hiddenReportsPath, makeReportsExtract, reportsPath} = require('../../util');
+const {getReportExtracts, hiddenReportsPath, reportsPath} = require('../../util');
 const fs = require('fs/promises');
 const path = require('path');
 
@@ -24,8 +24,6 @@ exports.answer = async (_, search) => {
       try {
         // Move the specified report to the directory of hidden reports.
         await fs.rename(path.join(reportsPath(), fileName), path.join(hiddenReportsPath(), fileName));
-        // Update the data on the available reports.
-        await makeReportsExtract();
       }
       // If this failed:
       catch (error) {

package/web/pruneReportsForm/index.js

@@ -5,7 +5,7 @@
 
 // IMPORTS
 
-const {getReportData, makeReportsExtract, reportsPath} = require('../../util');
+const {getReportData, reportsPath} = require('../../util');
 const fs = require('fs/promises');
 const path = require('path');
 
@@ -26,8 +26,6 @@ exports.answer = async (_, search) => {
           // Delete it.
           await fs.unlink(path.join(reportsPath(), `${jobName}.json`));
         }
-        // Update the extract of the available reports.
-        await makeReportsExtract();
       }
       // If this failed:
       catch (error) {

package/web/unhideReportForm/index.js

@@ -5,7 +5,7 @@
 
 // IMPORTS
 
-const {hiddenReportsPath, makeReportsExtract, reportsPath} = require('../../util');
+const {hiddenReportsPath, reportsPath} = require('../../util');
 const fs = require('fs/promises');
 const path = require('path');
 
@@ -24,8 +24,6 @@ exports.answer = async (_, search) => {
       try {
         // Move the report to the reports directory.
         await fs.rename(path.join(hiddenReportsPath(), fileName), path.join(reportsPath(), fileName));
-        // Update the data on the available reports.
-        await makeReportsExtract();
       }
       catch (error) {
         // Return why.