@jrpool/kilotest 46.0.8 → 46.0.14

package/web/pruneReportsForm/pruneReportsForm.test.js

@@ -0,0 +1,86 @@
+/*
+  pruneReportsForm.test.js
+  Unit tests for web/pruneReportsForm/index.js.
+*/
+
+// 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');
+
+// SETUP AND TEARDOWN
+
+const savedAuthCode = process.env.AUTH_CODE;
+const savedDBDir = process.env.DB_DIR;
+const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+
+before(() => {
+  process.env.AUTH_CODE = 'test-auth-code';
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+after(async () => {
+  if (savedAuthCode !== undefined) {
+    process.env.AUTH_CODE = savedAuthCode;
+  }
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+});
+
+// TESTS
+
+test('pruneReportsForm displays a list of reports when no submission', async () => {
+  const result = await answer(null, '');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  const html = parse(result.answerPage);
+  assert.ok(html.querySelector('title'));
+});
+
+test('pruneReportsForm returns an error for an invalid auth code', async () => {
+  const result = await answer(null, 'authCode=wrong&report=260101T0000-mix');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid authorization code');
+});
+
+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'));
+});
+
+test('pruneReportsForm deletes a superseded report with valid auth code', async () => {
+  // 260101T0000-mix is superseded by 260202T0000-new (same URL).
+  const reportPath = path.join(reportsPath(), '260101T0000-mix.json');
+  const backup = await fs.readFile(reportPath, 'utf8');
+  try {
+    const result = await answer(null, 'authCode=test-auth-code&report=260101T0000-mix');
+    assert.equal(result.status, 'ok');
+    await fs.access(reportPath).then(
+      () => {throw new Error('Report should have been deleted');},
+      () => {}
+    );
+  }
+  finally {
+    await fs.writeFile(reportPath, backup);
+  }
+});
+
+test('pruneReportsForm returns an error when a report file is corrupt', async () => {
+  const reportPath = path.join(reportsPath(), '260101T0001-ct.json');
+  const backup = await fs.readFile(reportPath, 'utf8');
+  try {
+    await fs.writeFile(reportPath, 'not valid json');
+    const result = await answer(null, '');
+    assert.equal(result.status, 'error');
+  }
+  finally {
+    await fs.writeFile(reportPath, backup);
+  }
+});

package/web/reannotate/reannotate.test.js

@@ -0,0 +1,144 @@
+/*
+  reannotate.test.js
+  Unit tests for web/reannotate/index.js, 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');
+
+// CONSTANTS
+
+const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+const reportsDir = path.join(fixtureDBDir, 'reports');
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  process.env.DB_DIR = fixtureDBDir;
+  process.env.AUTH_CODE = 'test-auth-code';
+});
+
+beforeEach(async () => {
+  // Ensure DB_DIR points to the fixture DB for each test.
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+after(async () => {
+  // Restore DB_DIR to the fixture DB.
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+// HELPER
+
+// Backs up all report files and returns a map of fileName to content.
+const backupReports = async () => {
+  const reportFiles = await fs.readdir(reportsDir);
+  const backups = {};
+  for (const file of reportFiles) {
+    backups[file] = await fs.readFile(path.join(reportsDir, file), 'utf8');
+  }
+  return backups;
+};
+
+// Restores all report files from a backup map.
+const restoreReports = async backups => {
+  for (const [file, content] of Object.entries(backups)) {
+    await fs.writeFile(path.join(reportsDir, file), content);
+  }
+};
+
+// TESTS
+
+test('answer returns an error for an invalid authorization code', async () => {
+  const {answer} = require('./index');
+  const result = await answer('wrong-code');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid authorization code');
+});
+
+test('answer returns an error when no reports are available', async () => {
+  // Create a temporary DB directory with an empty reports directory.
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'reannotate-test-'));
+  await fs.mkdir(path.join(tempDir, 'reports'));
+  const originalDBDir = process.env.DB_DIR;
+  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 result = await answer('test-auth-code');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Got data on no available reports');
+  }
+  finally {
+    process.env.DB_DIR = originalDBDir;
+    try {
+      await fs.rm(tempDir, {recursive: true});
+    }
+    catch {
+      // Ignore cleanup errors for the temp directory.
+    }
+  }
+});
+
+test('answer returns an error when a report fails annotation', async () => {
+  // Back up all fixture reports, because annotateReport 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
+  // getReport validation (acts is not an array).
+  const badReportName = '990101T0000-bad.json';
+  const badReportPath = path.join(reportsDir, badReportName);
+  const badReport = {
+    id: '990101T0000-bad',
+    target: {what: 'Bad Report', url: 'https://example.com/bad'},
+    acts: 'not-an-array',
+    jobData: {endTime: '26-01-01T00:00'},
+    catalog: {}
+  };
+  await fs.writeFile(badReportPath, JSON.stringify(badReport));
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    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}`);
+  }
+  finally {
+    try {
+      await fs.unlink(badReportPath);
+    }
+    catch {
+      // Ignore cleanup errors for the temporary bad report.
+    }
+    // Restore all fixture reports modified by annotateReport.
+    await restoreReports(backups);
+  }
+});
+
+test('answer returns ok with an answer page when all reports annotate successfully', async () => {
+  // Back up all fixture reports, because annotateReport modifies them in place.
+  const backups = await backupReports();
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer('test-auth-code');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage, 'answerPage should be present');
+    // Verify the HTML is well-formed.
+    const doc = parse(result.answerPage);
+    const h1 = doc.querySelector('h1');
+    assert.ok(h1);
+    assert.ok(h1.textContent.includes('Reannotation order'));
+  }
+  finally {
+    // Restore all fixture reports.
+    await restoreReports(backups);
+  }
+});

package/web/reannotateForm/reannotateForm.test.js

@@ -0,0 +1,134 @@
+/*
+  reannotateForm.test.js
+  Unit tests for web/reannotateForm/index.js, 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');
+
+// CONSTANTS
+
+const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+const reportsDir = path.join(fixtureDBDir, 'reports');
+const emptyReportName = '260101T0005-emp.json';
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  process.env.DB_DIR = fixtureDBDir;
+  process.env.AUTH_CODE = 'test-auth-code';
+});
+
+beforeEach(async () => {
+  // Ensure DB_DIR points to the fixture DB for each test.
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+after(async () => {
+  // Restore DB_DIR to the fixture DB.
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+// TESTS
+
+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 result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage, 'answerPage should be present');
+  // Verify the placeholders were replaced.
+  assert.ok(!result.answerPage.includes('__how__'));
+  assert.ok(!result.answerPage.includes('__reannotateForm__'));
+  assert.ok(!result.answerPage.includes('__stillUnclassified__'));
+  assert.ok(!result.answerPage.includes('__reClassified__'));
+  // Verify the how text mentions reclassified rules.
+  assert.ok(result.answerPage.includes('reclassified'));
+  // Verify the HTML is well-formed.
+  const doc = parse(result.answerPage);
+  const h1 = doc.querySelector('h1');
+  assert.ok(h1);
+  assert.ok(h1.textContent.includes('Reannotation order'));
+  // Verify the form is present.
+  const form = doc.querySelector('form');
+  assert.ok(form);
+  assert.equal(form.getAttribute('action'), '/reannotate.html');
+});
+
+test('answer returns ok with no-reclassified message when reports have no violations', async () => {
+  // Create a temporary DB directory with only the empty report (no instances).
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'reannotateForm-test-'));
+  const tempReportsDir = path.join(tempDir, 'reports');
+  await fs.mkdir(tempReportsDir);
+  // Copy the empty report (no standard instances) to the temp directory.
+  const emptyReportContent = await fs.readFile(path.join(reportsDir, emptyReportName), 'utf8');
+  await fs.writeFile(path.join(tempReportsDir, emptyReportName), emptyReportContent);
+  const originalDBDir = process.env.DB_DIR;
+  process.env.DB_DIR = tempDir;
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage, 'answerPage should be present');
+    // Verify the how text says reannotation is normally not necessary.
+    assert.ok(
+      result.answerPage.includes('normally not necessary'),
+      'Expected the no-reclassified message in the answer page'
+    );
+    // Verify no reclassified list items are present.
+    assert.ok(!result.answerPage.includes('reclassified</q> rule indicates'));
+    // Verify the HTML is well-formed.
+    const doc = parse(result.answerPage);
+    const form = doc.querySelector('form');
+    assert.ok(form);
+  }
+  finally {
+    process.env.DB_DIR = originalDBDir;
+    try {
+      await fs.rm(tempDir, {recursive: true});
+    }
+    catch {
+      // Ignore cleanup errors for the temp directory.
+    }
+  }
+});
+
+test('answer returns an error when a report fails to load', async () => {
+  // Create a temporary report file that passes getReportExtract but fails
+  // getReport validation (acts is not an array).
+  const badReportName = '990101T0000-bad.json';
+  const badReportPath = path.join(reportsDir, badReportName);
+  const badReport = {
+    id: '990101T0000-bad',
+    target: {what: 'Bad Report', url: 'https://example.com/bad'},
+    acts: 'not-an-array',
+    jobData: {endTime: '26-01-01T00:00'},
+    catalog: {}
+  };
+  await fs.writeFile(badReportPath, JSON.stringify(badReport));
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer();
+    assert.equal(result.status, 'error');
+    assert.ok(result.message.includes('invalid'), `Expected message about invalid report, got: ${result.message}`);
+  }
+  finally {
+    try {
+      await fs.unlink(badReportPath);
+    }
+    catch {
+      // Ignore cleanup errors for the temporary bad report.
+    }
+  }
+});

package/web/renewWCAG/renewWCAG.test.js

@@ -0,0 +1,124 @@
+/*
+  renewWCAG.test.js
+  Unit tests for web/renewWCAG/index.js, covering auth, fetch status, and success branches.
+*/
+
+// IMPORTS
+
+const {test, before, after, afterEach} = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {parse} = require('node-html-parser');
+
+// CONSTANTS
+
+const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+const wcagMapPath = path.join(__dirname, '..', '..', 'wcagMap.json');
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  process.env.DB_DIR = fixtureDBDir;
+  process.env.AUTH_CODE = 'test-auth-code';
+});
+
+let originalFetch;
+let wcagMapBackup;
+
+afterEach(async () => {
+  // Restore the original fetch after each test.
+  if (originalFetch !== undefined) {
+    global.fetch = originalFetch;
+    originalFetch = undefined;
+  }
+  // Restore the wcagMap.json file if it was backed up.
+  if (wcagMapBackup !== undefined) {
+    await fs.writeFile(wcagMapPath, wcagMapBackup);
+    wcagMapBackup = undefined;
+  }
+});
+
+after(async () => {
+  // Ensure fetch is restored.
+  if (originalFetch !== undefined) {
+    global.fetch = originalFetch;
+    originalFetch = undefined;
+  }
+});
+
+// HELPER
+
+// Replaces global.fetch with a mock that returns the given status and body.
+const mockFetch = (status, body = '') => {
+  originalFetch = global.fetch;
+  // @ts-expect-error: Replacing the real function with a mock for testing.
+  global.fetch = async () => ({
+    status,
+    text: async () => body
+  });
+};
+
+// TESTS
+
+test('answer returns an error for an invalid authorization code', async () => {
+  const {answer} = require('./index');
+  const result = await answer('wrong-code');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Authorization code invalid');
+});
+
+test('answer returns an error when the WCAG map source returns a non-200 status', async () => {
+  mockFetch(404);
+  delete require.cache[require.resolve('./index')];
+  const {answer} = require('./index');
+  const result = await answer('test-auth-code');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'WCAG map source not retrieved');
+});
+
+test('answer returns ok and rewrites the WCAG map when the source returns valid entries', async () => {
+  // Back up the existing wcagMap.json before the test overwrites it.
+  wcagMapBackup = await fs.readFile(wcagMapPath, 'utf8');
+  // Create mock HTML with entries matching the regex in index.js.
+  const mockHTML = [
+    '<a href="understanding/contrast-minimum"><span class="secno">1.4.3 </span>',
+    '<a href="understanding/non-text-content"><span class="secno">1.1.1 </span>',
+    '<a href="understanding/target-size-minimum"><span class="secno">2.5.8 </span>'
+  ].join('\n');
+  mockFetch(200, mockHTML);
+  delete require.cache[require.resolve('./index')];
+  const {answer} = require('./index');
+  const result = await answer('test-auth-code');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage, 'answerPage should be present');
+  // Verify the HTML is well-formed.
+  const doc = parse(result.answerPage);
+  const h1 = doc.querySelector('h1');
+  assert.ok(h1);
+  assert.ok(h1.textContent.includes('WCAG map renewed'));
+  // Verify the wcagMap.json was updated with the entries.
+  const updatedMap = JSON.parse(await fs.readFile(wcagMapPath, 'utf8'));
+  assert.equal(updatedMap['1.4.3'], 'understanding/contrast-minimum');
+  assert.equal(updatedMap['1.1.1'], 'understanding/non-text-content');
+  assert.equal(updatedMap['2.5.8'], 'understanding/target-size-minimum');
+});
+
+test('answer returns an error when matchAll returns no entries', async () => {
+  // Mock matchAll to return null, covering the dead else branch on lines 48-55.
+  const originalMatchAll = String.prototype.matchAll;
+  String.prototype.matchAll = function() {
+    return null;
+  };
+  mockFetch(200, '<html></html>');
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer('test-auth-code');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'No entries found in WCAG map source');
+  }
+  finally {
+    String.prototype.matchAll = originalMatchAll;
+  }
+});

package/web/requestRetest/requestRetest.test.js

@@ -0,0 +1,119 @@
+/*
+  requestRetest.test.js
+  Unit tests for web/requestRetest/index.js, covering the success path of answer.
+*/
+
+// IMPORTS
+
+const {test, before, after, beforeEach} = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {parse} = require('node-html-parser');
+
+// CONSTANTS
+
+const fixtureDBDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+const recsPath = path.join(fixtureDBDir, 'jobs', 'recs.json');
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  process.env.DB_DIR = fixtureDBDir;
+  process.env.AUTH_CODE = 'test-auth-code';
+});
+
+beforeEach(async () => {
+  // Reset recs.json and clean job directories before each test.
+  await fs.writeFile(recsPath, '{}\n');
+  for (const sub of ['claimed', 'queue', 'failed']) {
+    const dir = path.join(fixtureDBDir, 'jobs', sub);
+    await fs.mkdir(dir, {recursive: true});
+    const files = await fs.readdir(dir).catch(() => []);
+    for (const file of files) {
+      try {
+        await fs.unlink(path.join(dir, file));
+      }
+      catch {
+        // Ignore cleanup errors for files that may not exist.
+      }
+    }
+  }
+});
+
+after(async () => {
+  // Restore recs.json and clean job directories after all tests.
+  await fs.writeFile(recsPath, '{}\n');
+  for (const sub of ['claimed', 'queue', 'failed']) {
+    const dir = path.join(fixtureDBDir, 'jobs', sub);
+    await fs.mkdir(dir, {recursive: true});
+    const files = await fs.readdir(dir).catch(() => []);
+    for (const file of files) {
+      try {
+        await fs.unlink(path.join(dir, file));
+      }
+      catch {
+        // Ignore cleanup errors for files that may not exist.
+      }
+    }
+  }
+});
+
+// TESTS
+
+test('answer returns ok with a populated answer page for a valid retest request', async () => {
+  // Require the module after DB_DIR is set.
+  const {answer} = require('./index');
+  // Use the 260101T0001-ct report (All CantTell Page, https://example.com/canttell).
+  const result = await answer('260101T0001/ct', 'Because changes were made');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage, 'answerPage should be present');
+  // Verify the placeholders were replaced with the report target.
+  assert.ok(result.answerPage.includes('All CantTell Page'));
+  assert.ok(result.answerPage.includes('Because changes were made'));
+  assert.ok(!result.answerPage.includes('__target__'));
+  assert.ok(!result.answerPage.includes('__why__'));
+  // Verify the HTML is well-formed.
+  const doc = parse(result.answerPage);
+  const h1 = doc.querySelector('h1');
+  assert.ok(h1);
+  assert.ok(h1.textContent.includes('All CantTell Page'));
+});
+
+test('answer throws when the report does not exist', async () => {
+  const {answer} = require('./index');
+  // Use a nonexistent report timestamp and jobID.
+  await assert.rejects(
+    () => answer('990101T0000/xxx', 'Because changes were made'),
+    /Cannot destructure property 'error'/
+  );
+});
+
+test('answer returns an error for an invalid retest recommendation', async () => {
+  const {answer} = require('./index');
+  // Use a valid report but a too-short reason.
+  const result = await answer('260101T0001/ct', 'why');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid recommendation');
+});
+
+test('answer returns an error when the report extract has an error', async () => {
+  // Mock getLatestReportExtracts to return an extract with an error.
+  const util = require('../../util');
+  const original = util.getLatestReportExtracts;
+  util.getLatestReportExtracts = async () => [
+    {timeStamp: '260101T0001', jobID: 'ct', error: 'Report data unavailable'}
+  ];
+  try {
+    // Re-require to pick up the mocked function.
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer('260101T0001/ct', 'Because changes were made');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Report data unavailable');
+  }
+  finally {
+    util.getLatestReportExtracts = original;
+    delete require.cache[require.resolve('./index')];
+  }
+});

package/web/requestRetestForm/requestRetestForm.test.js

@@ -0,0 +1,62 @@
+/*
+  requestRetestForm.test.js
+  Unit tests for web/requestRetestForm/index.js.
+*/
+
+// IMPORTS
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const {parse} = require('node-html-parser');
+const {answer} = require('./index');
+
+// 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('requestRetestForm returns ok with the page name for a valid report', async () => {
+  const result = await answer('260202T0000/new');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  const html = parse(result.answerPage);
+  const title = html.querySelector('title').text;
+  assert.ok(title.includes('Mixed Outcomes Page'));
+});
+
+test('requestRetestForm populates the form action with the timeStamp and jobID', async () => {
+  const result = await answer('260202T0000/new');
+  const html = parse(result.answerPage);
+  const form = html.querySelector('form');
+  assert.equal(form.getAttribute('action'), '/requestRetest.html/260202T0000/new');
+});
+
+test('requestRetestForm shows the fallback message for a nonexistent report', async () => {
+  const result = await answer('999999T9999/nope');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('The specified page is not available for retesting'));
+});
+
+test('requestRetestForm includes the ago and dateTime placeholders replaced', async () => {
+  const result = await answer('260202T0000/new');
+  assert.ok(!result.answerPage.includes('__ago__'));
+  assert.ok(!result.answerPage.includes('__dateTime__'));
+  assert.ok(!result.answerPage.includes('__target__'));
+  assert.ok(!result.answerPage.includes('__timeStamp__'));
+  assert.ok(!result.answerPage.includes('__jobID__'));
+});