@jrpool/kilotest 46.0.8 → 46.0.14

package/web/listReports/listReports.test.js

@@ -8,6 +8,7 @@
 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');
 const {answer} = require('./index');
 
@@ -15,8 +16,12 @@ const {answer} = require('./index');
 
 const savedDBDir = process.env.DB_DIR;
 
-before(() => {
+before(async () => {
   process.env.DB_DIR = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  // Ensure job subdirectories exist (they are empty and not tracked by Git).
+  for (const sub of ['queue', 'claimed', 'failed']) {
+    await fs.mkdir(path.join(process.env.DB_DIR, 'jobs', sub), {recursive: true});
+  }
 });
 
 after(() => {
@@ -38,11 +43,11 @@ test('listReports returns an ok status with valid HTML', async () => {
   assert.equal(html.querySelector('title').text, 'Pages tested | Kilotest');
 });
 
-test('listReports includes the 6 non-hidden fixture reports as details elements', async () => {
+test('listReports includes the 8 non-hidden fixture reports as details elements', async () => {
   const result = await answer();
   const html = parse(result.answerPage);
   const details = html.querySelectorAll('details');
-  assert.equal(details.length, 6);
+  assert.equal(details.length, 8);
 });
 
 test('listReports includes the page descriptions in summary elements', async () => {
@@ -82,3 +87,134 @@ test('listReports includes a link to request testing a new page', async () => {
   const testLink = html.querySelector('a[href="requestTestForm.html"]');
   assert.ok(testLink);
 });
+
+test('listReports shows recommendations when recs.json has entries', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const recsPath = path.join(dbDir, 'jobs', 'recs.json');
+  const originalRecs = await fs.readFile(recsPath, 'utf8');
+  try {
+    const testRecs = {
+      'https://example.com/mixed': [
+        {what: 'Mixed Outcomes Page', why: 'Needs retesting for accessibility'}
+      ]
+    };
+    await fs.writeFile(recsPath, JSON.stringify(testRecs, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('https://example.com/mixed'));
+    assert.ok(result.answerPage.includes('Needs retesting for accessibility'));
+  }
+  finally {
+    await fs.writeFile(recsPath, originalRecs);
+  }
+});
+
+test('listReports shows queued and claimed jobs when they exist', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const queueDir = path.join(dbDir, 'jobs', 'queue');
+  const claimedDir = path.join(dbDir, 'jobs', 'claimed');
+  const queueFile = path.join(queueDir, 'queuedJob.json');
+  const claimedFile = path.join(claimedDir, 'claimedJob.json');
+  try {
+    const queuedJob = {
+      target: {url: 'https://example.com/queued', what: 'Queued Page'}
+    };
+    const claimedJob = {
+      target: {url: 'https://example.com/claimed', what: 'Claimed Page'}
+    };
+    await fs.writeFile(queueFile, JSON.stringify(queuedJob, null, 2));
+    await fs.writeFile(claimedFile, JSON.stringify(claimedJob, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('https://example.com/queued'));
+    assert.ok(result.answerPage.includes('Queued Page'));
+    assert.ok(result.answerPage.includes('https://example.com/claimed'));
+    assert.ok(result.answerPage.includes('Claimed Page'));
+  }
+  finally {
+    await fs.unlink(queueFile).catch(() => {});
+    await fs.unlink(claimedFile).catch(() => {});
+  }
+});
+
+test('listReports shows claimed retest status for a report with a matching claimed job', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const claimedDir = path.join(dbDir, 'jobs', 'claimed');
+  const claimedFile = path.join(claimedDir, 'claimedRetest.json');
+  try {
+    const claimedJob = {
+      target: {url: 'https://example.com/mixed', what: 'Mixed Outcomes Page'}
+    };
+    await fs.writeFile(claimedFile, JSON.stringify(claimedJob, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('Currently being retested'));
+  }
+  finally {
+    await fs.unlink(claimedFile).catch(() => {});
+  }
+});
+
+test('listReports shows queued retest status for a report with a matching queued job', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const queueDir = path.join(dbDir, 'jobs', 'queue');
+  const queueFile = path.join(queueDir, 'queuedRetest.json');
+  try {
+    const queuedJob = {
+      target: {url: 'https://example.com/mixed', what: 'Mixed Outcomes Page'}
+    };
+    await fs.writeFile(queueFile, JSON.stringify(queuedJob, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('Currently in the queue for retesting'));
+  }
+  finally {
+    await fs.unlink(queueFile).catch(() => {});
+  }
+});
+
+test('listReports returns an error when a report file is invalid', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportsDir = path.join(dbDir, 'reports');
+  const invalidReportPath = path.join(reportsDir, '260101T9999-bad.json');
+  try {
+    // Valid for getReportExtract (has target and jobData.endTime) but invalid for isValidReport (no acts or catalog).
+    const invalidReport = {
+      target: {what: 'Invalid Report', url: 'https://example.com/invalid'},
+      jobData: {endTime: '26-01-01T00:10'}
+    };
+    await fs.writeFile(invalidReportPath, JSON.stringify(invalidReport, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'error');
+    assert.ok(result.message);
+  }
+  finally {
+    await fs.unlink(invalidReportPath).catch(() => {});
+  }
+});
+
+test('listReports shows no-reports message when the database is empty', async () => {
+  // Create a temp DB with empty reports and jobs directories.
+  const os = require('node:os');
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'listreports-empty-'));
+  await fs.mkdir(path.join(tmpDir, 'reports'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'queue'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'claimed'), {recursive: true});
+  await fs.mkdir(path.join(tmpDir, 'jobs', 'failed'), {recursive: true});
+  await fs.writeFile(path.join(tmpDir, 'jobs', 'recs.json'), '{}\n');
+  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();
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('no'));
+    assert.ok(result.answerPage.includes(' a '));
+  }
+  finally {
+    process.env.DB_DIR = savedDBDir;
+    delete require.cache[require.resolve('./index')];
+    await fs.rm(tmpDir, {recursive: true}).catch(() => {});
+  }
+});

package/web/listRules/listRules.test.js

@@ -0,0 +1,103 @@
+/*
+  listRules.test.js
+  Unit tests for web/listRules/index.js.
+*/
+
+// IMPORTS
+
+const {test} = require('node:test');
+const assert = require('node:assert/strict');
+const {parse} = require('node-html-parser');
+
+// Monkey-patch testaro-issues to add a rule with what === ruleID,
+// covering the dead branch on line 55 of listRules/index.js.
+const testaroIssues = require('testaro-issues');
+const originalRules = testaroIssues.rules;
+const patchEngine = Object.keys(originalRules)[0];
+const patchType = Object.keys(originalRules[patchEngine])[0];
+const patchRuleID = '__testWhatEqualsID__';
+testaroIssues.rules = {
+  ...originalRules,
+  [patchEngine]: {
+    ...originalRules[patchEngine],
+    [patchType]: {
+      ...originalRules[patchEngine][patchType],
+      [patchRuleID]: {what: patchRuleID}
+    }
+  }
+};
+// Add the patched rule to an existing issue's rule list.
+const patchIssueID = Object.keys(testaroIssues.issueRules)[0];
+const originalIssueRules = testaroIssues.issueRules;
+testaroIssues.issueRules = {
+  ...originalIssueRules,
+  [patchIssueID]: {
+    ...originalIssueRules[patchIssueID],
+    [patchEngine]: {
+      ...originalIssueRules[patchIssueID][patchEngine],
+      [patchType]: [
+        ...originalIssueRules[patchIssueID][patchEngine][patchType],
+        patchRuleID
+      ]
+    }
+  }
+};
+
+const {answer} = require('./index');
+
+// TESTS
+
+test('listRules returns an error for a nonexistent issue ID', async () => {
+  const result = await answer('nonexistentIssue123');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Issue not found');
+});
+
+test('listRules returns ok with HTML for a valid issue with both invariant and variable rules', async () => {
+  // pageLanguage has both invariant and variable rules in nuVal.
+  const result = await answer('pageLanguage');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  const html = parse(result.answerPage);
+  assert.ok(html.querySelector('title'));
+  // Both invariant and variable rule sections should be present.
+  assert.ok(result.answerPage.includes('invariant rules'));
+  assert.ok(result.answerPage.includes('variable rules'));
+});
+
+test('listRules returns ok for an issue with only invariant rules', async () => {
+  // ignorable has only invariant rules in alfa.
+  const result = await answer('ignorable');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  // The invariant rules heading should be present.
+  assert.ok(result.answerPage.includes('invariant rules'));
+});
+
+test('listRules includes the issue why, priority, and wcag in the page', async () => {
+  const result = await answer('pageLanguage');
+  assert.ok(!result.answerPage.includes('__why__'));
+  assert.ok(!result.answerPage.includes('__priority__'));
+  assert.ok(!result.answerPage.includes('__wcag__'));
+});
+
+test('listRules includes rule descriptions with htmlSafe formatting', async () => {
+  const result = await answer('pageLanguage');
+  // Rules should be listed as <li> elements with <code> tags.
+  assert.ok(result.answerPage.includes('<li><code>'));
+});
+
+test('listRules renders a rule without description when what equals ruleID', async () => {
+  // The patched issue has a rule where what === ruleID.
+  const result = await answer(patchIssueID);
+  assert.equal(result.status, 'ok');
+  // The rule should appear without a colon-description separator.
+  assert.ok(result.answerPage.includes(patchRuleID));
+});
+
+test('listRules returns ok for an issue with no rules in issueRules', async () => {
+  // docHeadingNotH1 exists in issueSpecs but has no entry in issueRules.
+  const result = await answer('docHeadingNotH1');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+});

package/web/listTopIssues/listTopIssues.test.js

@@ -0,0 +1,126 @@
+/*
+  listTopIssues.test.js
+  UI tests for web/listTopIssues/index.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 fs = require('node:fs/promises');
+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('listTopIssues returns an ok status with valid HTML', async () => {
+  const result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  const html = parse(result.answerPage);
+  assert.ok(html.querySelector('title'));
+});
+
+test('listTopIssues includes priority headings in the page', async () => {
+  const result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('priority'));
+});
+
+test('listTopIssues returns an error when a report file is invalid', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportsDir = path.join(dbDir, 'reports');
+  const invalidReportPath = path.join(reportsDir, '260101T9999-bad.json');
+  try {
+    // Valid for getReportExtract (has target and jobData.endTime) but invalid for isValidReport (no acts or catalog).
+    const invalidReport = {
+      target: {what: 'Invalid TopIssues Report', url: 'https://example.com/invalidtop'},
+      jobData: {endTime: '26-01-01T00:10'}
+    };
+    await fs.writeFile(invalidReportPath, JSON.stringify(invalidReport, null, 2));
+    const result = await answer();
+    assert.equal(result.status, 'error');
+    assert.ok(result.message);
+  }
+  finally {
+    await fs.unlink(invalidReportPath).catch(() => {});
+  }
+});
+
+test('listTopIssues handles reports with unclassified issue IDs', async () => {
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportsDir = path.join(dbDir, 'reports');
+  const reportPath = path.join(reportsDir, '260101T0004-unc.json');
+  try {
+    const report = {
+      id: '260101T0004-unc',
+      what: 'Unclassified Issue Page',
+      target: {what: 'Unclassified Issue Page', url: 'https://example.com/unclassified'},
+      acts: [
+        {
+          type: 'test',
+          which: 'axe',
+          result: {
+            standardResult: {
+              instances: [
+                {
+                  ruleID: 'r99',
+                  what: 'Some unclassified issue',
+                  outcome: 'failed',
+                  count: 1,
+                  catalogIndex: '0',
+                  issueID: 'nonexistentIssue'
+                }
+              ]
+            }
+          }
+        }
+      ],
+      jobData: {
+        startTime: '26-01-01T00:00',
+        endTime: '26-01-01T00:10',
+        preventions: {},
+        issuelessRules: []
+      },
+      catalog: {
+        '0': {
+          tagName: 'DIV',
+          id: '',
+          startTag: '<div>',
+          text: '',
+          textLinkable: false,
+          boxID: '0:0:100:50',
+          pathID: '/html/body/div[1]'
+        }
+      },
+      images: {},
+      checkpoints: []
+    };
+    await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
+    const result = await answer();
+    // The unclassified issue is skipped, but the page should still render successfully.
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage);
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});

package/web/listViolators/index.js

@@ -84,8 +84,7 @@ const populateQuery = async (issueID, timeStamp, jobID, query) => {
       const pathID = instance.pathID || '/html';
       const catalogIndex = instance.catalogIndex || '0';
       const tagName = catalog[catalogIndex]?.tagName
-      ?? pathID?.split('/').pop().replace(/\[.+$/, '').toUpperCase()
-      ?? 'HTML';
+      ?? pathID.split('/').pop().replace(/\[.+$/, '').toUpperCase();
       violators[catalogIndex] ??= {
         pathID: getPathID(catalog, catalogIndex, pathID),
         tagName,

package/web/listViolators/listViolators.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
@@ -64,3 +88,235 @@ test('listViolators returns an error status for an unknown issue', async () => {
   const result = await answer('nonexistentIssue/260101T0000/mix');
   assert.equal(result.status, 'error');
 });
+
+test('listViolators returns an error when getReport fails after getPageDataStrings succeeds', async () => {
+  getReportCallCount = 0;
+  failGetReportOnCall = 1;
+  try {
+    const result = await answer('linkNoText/260101T0000/mix');
+    assert.equal(result.status, 'error');
+    assert.ok(result.message.includes('invalid'));
+  }
+  finally {
+    failGetReportOnCall = -1;
+  }
+});
+
+test('listViolators includes take-me-there links for text-linkable violators', 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');
+    assert.equal(result.status, 'ok');
+    assert.ok(result.answerPage.includes('Take me there'));
+    assert.ok(result.answerPage.includes('Take me there</q> links will open'));
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});
+
+test('listViolators 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');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'Report facts not obtained');
+  }
+  finally {
+    pageDataStringsOverride = null;
+  }
+});
+
+test('listViolators handles instances with missing catalogIndex and acts with no standardResult', async () => {
+  // Create a temporary report with:
+  // - An act that has no standardResult (covers ?? [] on line 77)
+  // - An instance with no catalogIndex (covers || '0' on line 85)
+  // - A catalog entry with no tagName (covers ?? pathID fallback on lines 87-88)
+  // - Multiple violators (covers plural count on line 101)
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportPath = path.join(dbDir, 'reports', '260101T0004-nvi.json');
+  const report = {
+    id: '260101T0004-nvi',
+    target: {what: 'No Violator Info Page', url: 'https://example.com/nvi'},
+    acts: [
+      // Act with no standardResult (covers ?? [] fallback).
+      {type: 'test', which: 'alfa', result: {}},
+      // Act with instances that have missing catalogIndex.
+      {
+        type: 'test',
+        which: 'axe',
+        result: {
+          standardResult: {
+            instances: [
+              {
+                ruleID: 'r11',
+                what: 'The link does not have an accessible name',
+                outcome: 'failed',
+                issueID: 'linkNoText',
+                pathID: '/html/body/a[1]'
+                // No catalogIndex: defaults to '0'
+              },
+              {
+                ruleID: 'r12',
+                what: 'Another link without a name',
+                outcome: 'failed',
+                issueID: 'linkNoText',
+                pathID: '/html/body/div[1]/span[2]',
+                catalogIndex: '1'
+              }
+            ]
+          }
+        }
+      }
+    ],
+    jobData: {
+      startTime: '26-01-01T00:00',
+      endTime: '26-01-01T00:10',
+      preventions: {},
+      issuelessRules: []
+    },
+    catalog: {
+      '0': {
+        // No tagName: covers ?? pathID fallback.
+        id: '',
+        text: 'Click here',
+        pathID: '/html/body/a[1]'
+      },
+      '1': {
+        tagName: 'SPAN',
+        id: '',
+        text: 'More text',
+        pathID: '/html/body/div[1]/span[2]'
+      }
+    },
+    images: {},
+    checkpoints: []
+  };
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    const result = await answer('linkNoText/260101T0004/nvi');
+    assert.equal(result.status, 'ok');
+    // Should show plural violator count.
+    assert.ok(result.answerPage.includes('2 violators were'));
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});
+
+test('listViolators uses HTML fallback when catalog has no tagName and pathID is missing', async () => {
+  // Create a report where an instance has no pathID and the catalog
+  // entry has no tagName, so the ?? 'HTML' fallback is hit.
+  // Also uses a catalogIndex not in the catalog to cover || {} on line 144.
+  const dbDir = path.join(__dirname, '..', '..', 'test', 'fixtures', 'db');
+  const reportPath = path.join(dbDir, 'reports', '260101T0005-htm.json');
+  const report = {
+    id: '260101T0005-htm',
+    target: {what: 'HTML Fallback Page', url: 'https://example.com/htm'},
+    acts: [
+      {
+        type: 'test',
+        which: 'axe',
+        result: {
+          standardResult: {
+            instances: [
+              {
+                ruleID: 'r11',
+                what: 'The link does not have an accessible name',
+                outcome: 'failed',
+                issueID: 'linkNoText',
+                catalogIndex: '0'
+                // No pathID: triggers ?? 'HTML' fallback
+              },
+              {
+                ruleID: 'r12',
+                what: 'Another violation',
+                outcome: 'failed',
+                issueID: 'linkNoText',
+                catalogIndex: '99'
+                // catalogIndex '99' is not in the catalog, covers || {} on line 144
+              }
+            ]
+          }
+        }
+      }
+    ],
+    jobData: {
+      startTime: '26-01-01T00:00',
+      endTime: '26-01-01T00:10',
+      preventions: {},
+      issuelessRules: []
+    },
+    catalog: {
+      '0': {
+        // No tagName and no pathID: both fallbacks are nullish.
+        id: '',
+        text: 'Some text'
+      }
+      // Note: no '99' entry, so catalog['99'] is undefined.
+    },
+    images: {},
+    checkpoints: []
+  };
+  await fs.writeFile(reportPath, JSON.stringify(report));
+  try {
+    const result = await answer('linkNoText/260101T0005/htm');
+    assert.equal(result.status, 'ok');
+    // The tagName should fall back to HTML.
+    assert.ok(result.answerPage.includes('HTML'));
+  }
+  finally {
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});