@jrpool/kilotest 46.0.5 → 46.0.7

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.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']);
+});