@jrpool/kilotest 46.0.8 → 46.0.14

package/web/ai0BalanceForm/ai0BalanceForm.test.js

@@ -0,0 +1,88 @@
+/*
+  ai0BalanceForm.test.js
+  Unit tests for web/ai0BalanceForm/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');
+
+// CONSTANTS
+
+const balancePath = path.join(__dirname, '..', '..', 'ai0Balance.json');
+
+// SETUP AND TEARDOWN
+
+const savedAuthCode = process.env.AUTH_CODE;
+let savedBalance;
+
+before(async () => {
+  process.env.AUTH_CODE = 'test-auth-code';
+  savedBalance = await fs.readFile(balancePath, 'utf8').catch(() => null);
+  // Ensure the balance file exists so the try block in index.js is covered.
+  if (savedBalance === null) {
+    await fs.writeFile(balancePath, '{"balance":0}\n');
+  }
+});
+
+after(async () => {
+  if (savedAuthCode !== undefined) {
+    process.env.AUTH_CODE = savedAuthCode;
+  }
+  if (savedBalance !== null) {
+    await fs.writeFile(balancePath, savedBalance);
+  }
+  else {
+    await fs.unlink(balancePath).catch(() => {});
+  }
+});
+
+// TESTS
+
+test('ai0BalanceForm displays the current balance when no newBalance is submitted', 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('ai0BalanceForm returns an error for an invalid auth code', async () => {
+  const result = await answer(null, 'authCode=wrong&newBalance=5.00');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid authorization code');
+});
+
+test('ai0BalanceForm records a valid new balance with valid auth code', async () => {
+  const result = await answer(null, 'authCode=test-auth-code&newBalance=2.50');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('$2.5 is the'));
+  // Verify the file was written.
+  const data = JSON.parse(await fs.readFile(balancePath, 'utf8'));
+  assert.equal(data.balance, 2.50);
+});
+
+test('ai0BalanceForm does not record an invalid balance', async () => {
+  // 150 is out of range (>= 100).
+  const result = await answer(null, 'authCode=test-auth-code&newBalance=150');
+  assert.equal(result.status, 'ok');
+  // The oldBalance should not show the new value.
+  assert.ok(!result.answerPage.includes('$150 is the'));
+});
+
+test('ai0BalanceForm shows no-balance message when balance file is missing', async () => {
+  await fs.unlink(balancePath).catch(() => {});
+  try {
+    const result = await answer(null, '');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('There is no'));
+  }
+  finally {
+    await fs.writeFile(balancePath, savedBalance || '{"balance":0}');
+  }
+});

package/web/expungeReportsForm/expungeReportsForm.test.js

@@ -0,0 +1,114 @@
+/*
+  expungeReportsForm.test.js
+  Unit tests for web/expungeReportsForm/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('expungeReportsForm 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('expungeReportsForm returns an error for an invalid auth code', async () => {
+  const result = await answer(null, 'authCode=wrong&report=260101T0001-ct');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid authorization code');
+});
+
+test('expungeReportsForm 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 sole reports'));
+});
+
+test('expungeReportsForm deletes a sole report with valid auth code', async () => {
+  // 260101T0001-ct is the only report for its URL (canttell).
+  const reportPath = path.join(reportsPath(), '260101T0001-ct.json');
+  const backup = await fs.readFile(reportPath, 'utf8');
+  try {
+    const result = await answer(null, 'authCode=test-auth-code&report=260101T0001-ct');
+    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('expungeReportsForm 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);
+  }
+});
+
+test('expungeReportsForm shows no-deletable message when every URL has at least 2 reports', async () => {
+  // Create a temp DB with two reports sharing the same URL.
+  const os = require('node:os');
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'expunge-test-'));
+  const tmpReports = path.join(tmpDir, 'reports');
+  await fs.mkdir(tmpReports);
+  // Copy two reports that share the same URL.
+  const mixReport = await fs.readFile(path.join(fixtureDBDir, 'reports', '260101T0000-mix.json'), 'utf8');
+  const newReport = await fs.readFile(path.join(fixtureDBDir, 'reports', '260202T0000-new.json'), 'utf8');
+  await fs.writeFile(path.join(tmpReports, '260101T0000-mix.json'), mixReport);
+  await fs.writeFile(path.join(tmpReports, '260202T0000-new.json'), newReport);
+  const savedDBDir = process.env.DB_DIR;
+  process.env.DB_DIR = tmpDir;
+  try {
+    delete require.cache[require.resolve('./index')];
+    const {answer} = require('./index');
+    const result = await answer(null, '');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('no reports to delete'));
+    assert.ok(result.answerPage.includes('disabled'));
+  }
+  finally {
+    process.env.DB_DIR = savedDBDir;
+    delete require.cache[require.resolve('./index')];
+    await fs.rm(tmpDir, {recursive: true}).catch(() => {});
+  }
+});

package/web/hideReportForm/hideReportForm.test.js

@@ -0,0 +1,82 @@
+/*
+  hideReportForm.test.js
+  Unit tests for web/hideReportForm/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, hiddenReportsPath} = 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;
+  }
+  // Restore any moved report.
+  const reportFile = path.join(hiddenReportsPath(), '260101T0009-brd.json');
+  const originalPath = path.join(reportsPath(), '260101T0009-brd.json');
+  try {
+    await fs.rename(reportFile, originalPath);
+  }
+  catch {
+    // Report may already be in place.
+  }
+});
+
+// TESTS
+
+test('hideReportForm 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);
+  const radios = html.querySelectorAll('input[type="radio"]');
+  assert.ok(radios.length > 0);
+});
+
+test('hideReportForm returns an error for an invalid auth code', async () => {
+  const result = await answer(null, 'authCode=wrong&report=260101T0009-brd');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid authorization code');
+});
+
+test('hideReportForm hides a report with valid auth code', async () => {
+  const reportPath = path.join(reportsPath(), '260101T0009-brd.json');
+  const hiddenPath = path.join(hiddenReportsPath(), '260101T0009-brd.json');
+  // Ensure the report exists in reports and not in hidden.
+  try {
+    await fs.rename(hiddenPath, reportPath);
+  }
+  catch {
+    // Report may already be in reports.
+  }
+  const result = await answer(null, 'authCode=test-auth-code&report=260101T0009-brd');
+  assert.equal(result.status, 'ok');
+  // The report should now be in the hidden directory.
+  await fs.access(hiddenPath);
+});
+
+test('hideReportForm returns an error when hiding 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('Hiding report'));
+});

package/web/listDiagnoses/listDiagnoses.test.js

@@ -8,7 +8,31 @@
 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');
+
+// 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;
+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;
+  }
+  return realGetPageDataStrings(...args);
+};
+
 const {answer} = require('./index');
 
 // SETUP AND TEARDOWN
@@ -72,3 +96,139 @@ test('listDiagnoses returns ok with no diagnoses for a nonexistent catalog index
   const diagnosisTexts = diagnosisItems.map(li => li.text);
   assert.ok(!diagnosisTexts.some(t => t.includes('The link does not have an accessible name')));
 });
+
+test('listDiagnoses returns an error when getReport fails after getPageDataStrings succeeds', async () => {
+  getReportCallCount = 0;
+  failGetReportOnCall = 1;
+  try {
+    const result = await answer('linkNoText/260101T0000/mix/0');
+    assert.equal(result.status, 'error');
+    assert.ok(result.message.includes('invalid'));
+  }
+  finally {
+    failGetReportOnCall = -1;
+  }
+});
+
+test('listDiagnoses includes a take-me-there link for a text-linkable catalog item', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportsDir = path.join(dbDir, 'reports');
+  const reportPath = path.join(reportsDir, '260101T0003-tlk.json');
+  try {
+    const report = {
+      id: '260101T0003-tlk',
+      what: 'Text Linkable Page',
+      target: {what: 'Text Linkable Page', url: 'https://example.com/textlinkable'},
+      acts: [
+        {
+          type: 'test',
+          which: 'axe',
+          result: {
+            standardResult: {
+              instances: [
+                {
+                  ruleID: 'r11',
+                  what: 'The link does not have an accessible name',
+                  outcome: 'failed',
+                  count: 1,
+                  catalogIndex: '0',
+                  issueID: 'linkNoText'
+                }
+              ]
+            }
+          }
+        }
+      ],
+      jobData: {
+        startTime: '26-01-01T00:00',
+        endTime: '26-01-01T00:10',
+        preventions: {},
+        issuelessRules: []
+      },
+      catalog: {
+        '0': {
+          tagName: 'A',
+          id: '',
+          startTag: '<a>',
+          text: 'Click here',
+          textLinkable: true,
+          boxID: '10:20:80:30',
+          pathID: '/html/body/a[1]'
+        }
+      },
+      images: {},
+      checkpoints: []
+    };
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    const result = await answer('linkNoText/260101T0003/tlk/0');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('Take me there'));
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});
+
+test('listDiagnoses returns an error for an unknown issue with a valid report', async () => {
+  const result = await answer('nonexistentIssue/260101T0000/mix/0');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Issue not found');
+});
+
+test('listDiagnoses returns an error when report facts are not obtained', async () => {
+  pageDataStringsOverride = {
+    what: 'Mixed Outcomes Page',
+    url: 'https://example.com/mixed',
+    urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
+  };
+  try {
+    const result = await answer('linkNoText/260101T0000/mix/0');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Report facts not obtained');
+  }
+  finally {
+    pageDataStringsOverride = null;
+  }
+});
+
+test('listDiagnoses handles acts with no standardResult instances gracefully', async () => {
+  // Create a temporary report where an act has no standardResult.
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportPath = path.join(dbDir, 'reports', '260101T0004-nst.json');
+  const report = {
+    id: '260101T0004-nst',
+    target: {what: 'No Standard Result Page', url: 'https://example.com/noresult'},
+    acts: [
+      {
+        type: 'test',
+        which: 'axe',
+        result: {}
+      }
+    ],
+    jobData: {
+      startTime: '26-01-01T00:00',
+      endTime: '26-01-01T00:10',
+      preventions: {},
+      issuelessRules: []
+    },
+    catalog: {
+      '0': {
+        tagName: 'A',
+        id: '',
+        startTag: '<a>',
+        text: 'Click here',
+        pathID: '/html/body/a[1]'
+      }
+    },
+    images: {},
+    checkpoints: []
+  };
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    const result = await answer('linkNoText/260101T0004/nst/0');
+    assert.equal(result.status, 'ok');
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});

package/web/listIssues/listIssues.test.js

@@ -9,6 +9,29 @@ const {test, before, after} = require('node:test');
 const assert = require('node:assert/strict');
 const path = require('node:path');
 const {parse} = require('node-html-parser');
+
+// Monkey-patch util functions before requiring index, so that index.js
+// destructures the patched versions.
+const util = require('../../util');
+const realIsHidden = util.isHidden;
+const realGetPageDataStrings = util.getPageDataStrings;
+let isHiddenCallCount = 0;
+let forceHiddenOnCall = -1;
+let pageDataStringsOverride = null;
+util.isHidden = async (timeStamp, jobID) => {
+  isHiddenCallCount++;
+  if (isHiddenCallCount === forceHiddenOnCall) {
+    return true;
+  }
+  return realIsHidden(timeStamp, jobID);
+};
+util.getPageDataStrings = async (...args) => {
+  if (pageDataStringsOverride !== null) {
+    return pageDataStringsOverride;
+  }
+  return realGetPageDataStrings(...args);
+};
+
 const {answer} = require('./index');
 
 // SETUP AND TEARDOWN
@@ -78,3 +101,89 @@ test('listIssues for the empty report shows no issue links', async () => {
   const violatorLinks = html.querySelectorAll('a[href*="listViolators.html"]');
   assert.equal(violatorLinks.length, 0);
 });
+
+test('listIssues returns an error when a report becomes hidden during processing', async () => {
+  isHiddenCallCount = 0;
+  forceHiddenOnCall = 2;
+  try {
+    const result = await answer('260101T0000/mix');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Report is not available');
+  }
+  finally {
+    forceHiddenOnCall = -1;
+  }
+});
+
+test('listIssues includes prevention notices for the prevented report', async () => {
+  const result = await answer('260101T0006/prv');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('Page not testable by'));
+  assert.ok(result.answerPage.includes('page timed out'));
+});
+
+test('listIssues returns an error when getPageDataStrings fails after getData succeeds', async () => {
+  pageDataStringsOverride = {error: 'Page data strings error'};
+  try {
+    const result = await answer('260101T0000/mix');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Page data strings error');
+  }
+  finally {
+    pageDataStringsOverride = null;
+  }
+});
+
+test('listIssues returns an error when report facts are not obtained', async () => {
+  pageDataStringsOverride = {
+    what: 'Mixed Outcomes Page',
+    url: 'https://example.com/mixed',
+    urlLink: '<a href="https://example.com/mixed">https://example.com/mixed</a>'
+  };
+  try {
+    const result = await answer('260101T0000/mix');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Report facts not obtained');
+  }
+  finally {
+    pageDataStringsOverride = null;
+  }
+});
+
+test('listIssues shows plural violator count for an issue with multiple violators', async () => {
+  // The mul report has linkNoText with 3 violators.
+  const result = await answer('260101T0008/mul');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('3 violators were'));
+});
+
+test('listIssues handles acts with no standardResult instances', async () => {
+  // Create a temporary report with an act that has no standardResult.
+  const fs = require('node:fs/promises');
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportPath = path.join(dbDir, 'reports', '260101T0004-nsi.json');
+  const report = {
+    id: '260101T0004-nsi',
+    target: {what: 'No Std Instances Page', url: 'https://example.com/nsi'},
+    acts: [
+      {type: 'test', which: 'axe', result: {}}
+    ],
+    jobData: {
+      startTime: '26-01-01T00:00',
+      endTime: '26-01-01T00:10',
+      preventions: {},
+      issuelessRules: []
+    },
+    catalog: {},
+    images: {},
+    checkpoints: []
+  };
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    const result = await answer('260101T0004/nsi');
+    assert.equal(result.status, 'ok');
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});