@jrpool/kilotest 47.0.1 → 49.0.0

package/web/metrics/metrics.test.ts

@@ -0,0 +1,211 @@
+/*
+  metrics.test.ts
+  Unit tests for web/metrics/index.ts.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import {parse} from 'node-html-parser';
+import {answer} from './index.ts';
+import {getJSON, metricsPath} from '../../util.ts';
+
+// SETUP AND TEARDOWN
+
+const savedAuthCode = process.env.AUTH_CODE;
+const savedDBDir = process.env.DB_DIR;
+import {fixtureDBDir} from '../../test/dbFixture.ts';
+
+before(() => {
+  process.env.AUTH_CODE = 'test-auth-code';
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+after(() => {
+  if (savedAuthCode !== undefined) {
+    process.env.AUTH_CODE = savedAuthCode;
+  }
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+});
+
+// TESTS
+
+test('metrics returns an error for an invalid auth code on a POST request', async () => {
+  const result: any = await answer(null, 'authCode=wrong', 'POST');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Invalid request');
+});
+
+test('metrics displays a form requesting an auth code on a GET request', async () => {
+  const result: any = await answer(null, '', 'GET');
+  assert.equal(result.status, 'ok');
+  const html = parse(result.answerPage);
+  const input = html.querySelector('input[name="authCode"]');
+  assert.ok(input);
+  assert.equal(html.querySelectorAll('table').length, 0);
+});
+
+test('metrics displays a clearCounts checkbox in the initial form', async () => {
+  const result: any = await answer(null, '', 'GET');
+  const html = parse(result.answerPage);
+  const checkbox = html.querySelector('input[name="clearCounts"]');
+  assert.ok(checkbox);
+  assert.equal(checkbox.getAttribute('type'), 'checkbox');
+});
+
+test('metrics submits its form as a POST', async () => {
+  const result: any = await answer(null, '', 'GET');
+  const html = parse(result.answerPage);
+  const form = html.querySelector('form');
+  assert.equal(form?.getAttribute('method'), 'post');
+});
+
+test('metrics ignores a valid authCode query string on a GET request', async () => {
+  const result: any = await answer(null, 'authCode=test-auth-code', 'GET');
+  assert.equal(result.status, 'ok');
+  const html = parse(result.answerPage);
+  // The form (not the counts) should still be shown, since only POST submits.
+  assert.ok(html.querySelector('input[name="authCode"]'));
+  assert.equal(html.querySelectorAll('table').length, 0);
+});
+
+test('metrics ignores clearCounts on a GET request, even with a valid authCode', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {tutorialWeb: 9},
+    mcpToolCalls: {},
+    apiOperations: {},
+    managerActivity: {}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code&clearCounts=on', 'GET');
+  assert.ok(!result.answerPage.includes('Counts cleared.'));
+  const metrics = JSON.parse(await fs.readFile(metricsPath(), 'utf8'));
+  // The counts should NOT have been cleared by a mere GET request.
+  assert.equal(metrics.pageViews.tutorialWeb, 9);
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics reports no counts yet when the metrics file does not exist', async () => {
+  await fs.rm(metricsPath(), {force: true});
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('Counts recorded since'));
+  const html = parse(result.answerPage);
+  assert.equal(html.querySelectorAll('table').length, 0);
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics reports recorded counts with a valid auth code on a POST request', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {tutorialWeb: 3},
+    mcpToolCalls: {listReports: 5},
+    apiOperations: {},
+    managerActivity: {}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  assert.equal(result.status, 'ok');
+  const html = parse(result.answerPage);
+  const tables = html.querySelectorAll('table');
+  assert.equal(tables.length, 2);
+  assert.ok(result.answerPage.includes('tutorialWeb'));
+  assert.ok(result.answerPage.includes('5'));
+  assert.ok(result.answerPage.includes('at 00:00'));
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics sorts each category by descending count', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {manage: 1, tutorialWeb: 9, otherPage: 4},
+    mcpToolCalls: {},
+    apiOperations: {},
+    managerActivity: {}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  const html = parse(result.answerPage);
+  const names = html.querySelectorAll('table')[0]!.querySelectorAll('tbody td:first-child')
+  .map(cell => cell.text);
+  assert.deepEqual(names, ['tutorialWeb', 'otherPage', 'manage']);
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics reports manager page activity, sorted by descending failure count', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {},
+    mcpToolCalls: {},
+    apiOperations: {},
+    managerActivity: {
+      metrics: {ok: 5, error: 0},
+      reannotate: {ok: 1, error: 8}
+    }
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  assert.ok(result.answerPage.includes('Manager page activity'));
+  const html = parse(result.answerPage);
+  const tables = html.querySelectorAll('table');
+  assert.equal(tables.length, 1);
+  const managerTable = tables[0]!;
+  const rows = managerTable.querySelectorAll('tbody tr').map(row =>
+    row.querySelectorAll('td').map(cell => cell.text)
+  );
+  assert.deepEqual(rows, [['reannotate', '1', '8'], ['metrics', '5', '0']]);
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics reports no manager activity yet when none has been recorded', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {},
+    mcpToolCalls: {},
+    apiOperations: {},
+    managerActivity: {}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  const html = parse(result.answerPage);
+  assert.equal(html.querySelectorAll('table').length, 0);
+  assert.ok(result.answerPage.includes('None yet.'));
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics clears all counts and shows a confirmation when clearCounts is submitted via POST', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {tutorialWeb: 9},
+    mcpToolCalls: {listReports: 3},
+    apiOperations: {getReport: 1},
+    managerActivity: {reannotate: {ok: 1, error: 2}}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code&clearCounts=on', 'POST');
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage.includes('Counts cleared.'));
+  const html = parse(result.answerPage);
+  assert.equal(html.querySelectorAll('table').length, 0);
+  const metrics = JSON.parse(await fs.readFile(metricsPath(), 'utf8'));
+  assert.deepEqual(metrics.pageViews, {});
+  assert.deepEqual(metrics.mcpToolCalls, {});
+  assert.deepEqual(metrics.apiOperations, {});
+  assert.deepEqual(metrics.managerActivity, {});
+  assert.notEqual(metrics.since, '260101T0000');
+  await fs.rm(metricsPath(), {force: true});
+});
+
+test('metrics does not clear counts, and does not show a confirmation, when clearCounts is not submitted', async () => {
+  await fs.writeFile(metricsPath(), getJSON({
+    since: '260101T0000',
+    pageViews: {tutorialWeb: 9},
+    mcpToolCalls: {},
+    apiOperations: {},
+    managerActivity: {}
+  }));
+  const result: any = await answer(null, 'authCode=test-auth-code', 'POST');
+  assert.ok(!result.answerPage.includes('Counts cleared.'));
+  const metrics = JSON.parse(await fs.readFile(metricsPath(), 'utf8'));
+  assert.equal(metrics.pageViews.tutorialWeb, 9);
+  await fs.rm(metricsPath(), {force: true});
+});

package/web/pruneReportsForm/index.html

@@ -14,7 +14,7 @@
     <main>
       <h1><a href="/">Kilotest</a>: Prune reports</h1>
       <p>__intro__</p>
-      <form action="/pruneReportsForm.html">
+      <form action="/pruneReportsForm.html" method="post">
         <fieldset>
           <legend>Reports</legend>
           __reports__

package/web/pruneReportsForm/index.ts

@@ -10,7 +10,7 @@ import {reportDeletionForm} from '../reportDeletion.ts';
 // FUNCTIONS
 
 // Returns a form for deleting non-latest reports.
-export const answer = async (_: any, search: string) => reportDeletionForm(import.meta.dirname, search, {
+export const answer = async (_: any, search: string, method: string) => reportDeletionForm(import.meta.dirname, search, method, {
   intro: 'Choose the superseded reports to delete.',
   emptyIntro: 'Each target has only 1 report, so there are no superseded reports to delete.',
   failurePrefix: 'Deleting superseded reports failed',

package/web/pruneReportsForm/pruneReportsForm.test.ts

@@ -35,32 +35,40 @@ after(async () => {
 
 // TESTS
 
-test('pruneReportsForm displays a list of reports when no submission', async () => {
-  const result = await answer(null, '');
+test('pruneReportsForm displays a list of reports on a GET request', async () => {
+  const result = await answer(null, '', 'GET');
   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');
+test('pruneReportsForm ignores a report query string on a GET request', async () => {
+  const reportPath = path.join(reportsPath(), '260101T0000-mix.json');
+  const result = await answer(null, 'authCode=test-auth-code&report=260101T0000-mix', 'GET');
+  assert.equal(result.status, 'ok');
+  // The report should NOT have been deleted by a mere GET request.
+  await fs.access(reportPath);
+});
+
+test('pruneReportsForm returns an error for an invalid auth code on a POST request', async () => {
+  const result = await answer(null, 'authCode=wrong&report=260101T0000-mix', 'POST');
   assert.equal(result.status, 'error');
-  assert.equal(result.message, 'Invalid authorization code');
+  assert.equal(result.message, 'Invalid request');
 });
 
-test('pruneReportsForm returns an error when deleting a nonexistent report', async () => {
-  const result = await answer(null, 'authCode=test-auth-code&report=999999T9999-nope');
+test('pruneReportsForm returns an error when deleting a nonexistent report on a POST request', async () => {
+  const result = await answer(null, 'authCode=test-auth-code&report=999999T9999-nope', 'POST');
   assert.equal(result.status, 'error');
   assert.ok(result.message?.includes('Deleting superseded reports'));
 });
 
-test('pruneReportsForm deletes a superseded report with valid auth code', async () => {
+test('pruneReportsForm deletes a superseded report with valid auth code on a POST request', 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');
+    const result = await answer(null, 'authCode=test-auth-code&report=260101T0000-mix', 'POST');
     assert.equal(result.status, 'ok');
     await fs.access(reportPath).then(
       () => {throw new Error('Report should have been deleted');},
@@ -77,7 +85,7 @@ test('pruneReportsForm returns an error when a report file is corrupt', async ()
   const backup = await fs.readFile(reportPath, 'utf8');
   try {
     await fs.writeFile(reportPath, 'not valid json');
-    const result = await answer(null, '');
+    const result = await answer(null, '', 'GET');
     assert.equal(result.status, 'error');
   }
   finally {

package/web/reannotate/index.ts

@@ -11,6 +11,7 @@ import {
   getReport,
   getReportPath,
   isReportError,
+  readdirOrCreate,
   reportsPath
 } from '../../util.ts';
 import fs from 'node:fs/promises';
@@ -23,7 +24,7 @@ export const answer = async (authCode: string) => {
   // If the authorization code is valid:
   if (authCode === process.env.AUTH_CODE) {
     // Get the names of the stored report files.
-    const reportFileNames = (await fs.readdir(reportsPath()))
+    const reportFileNames = (await readdirOrCreate(reportsPath(), 'Reports directory'))
     .filter(fileName => fileName.endsWith('.json'));
     // If any exist:
     if (reportFileNames.length) {
@@ -62,9 +63,12 @@ export const answer = async (authCode: string) => {
       answerPage
     };
   }
-  // Otherwise, i.e. if the authorization code is invalid, return an error page.
+  // Otherwise, i.e. if the authorization code is invalid, return an error page. The
+  // message is deliberately vague so as not to confirm to an attacker that the
+  // authorization code specifically (as opposed to some other part of the request) is
+  // what was wrong.
   return {
     status: 'error',
-    message: 'Invalid authorization code'
+    message: 'Invalid request'
   };
 };

package/web/reannotate/reannotate.test.ts

@@ -59,7 +59,7 @@ test('answer returns an error for an invalid authorization code', async () => {
   const {answer} = await import('./index.ts');
   const result = await answer('wrong-code');
   assert.equal(result.status, 'error');
-  assert.equal(result.message, 'Invalid authorization code');
+  assert.equal(result.message, 'Invalid request');
 });
 
 test('answer returns an error when no reports are available', async () => {

package/web/renewWCAG/index.ts

@@ -61,10 +61,13 @@ export const answer = async (authCode: string) => {
       };
     }
   }
+  // The message is deliberately vague so as not to confirm to an attacker that the
+  // authorization code specifically (as opposed to some other part of the request) is
+  // what was wrong.
   else {
     return {
       status: 'error',
-      message: 'Authorization code invalid'
+      message: 'Invalid request'
     };
   }
 };

package/web/renewWCAG/renewWCAG.test.ts

@@ -65,7 +65,7 @@ test('answer returns an error for an invalid authorization code', async () => {
   const {answer} = await import('./index.ts');
   const result = await answer('wrong-code');
   assert.equal(result.status, 'error');
-  assert.equal(result.message, 'Authorization code invalid');
+  assert.equal(result.message, 'Invalid request');
 });
 
 test('answer returns an error when the WCAG map source returns a non-200 status', async () => {

package/web/reportDeletion.ts

@@ -6,7 +6,7 @@
 // IMPORTS
 
 import {
-  errorMessage, getReportData, objectSort, populateTemplate, reportsPath
+  errorMessage, getReportData, objectSort, populateTemplate, readdirOrCreate, reportsPath
 } from '../util.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -32,18 +32,21 @@ export type DeletionSpec = {
 
 // FUNCTIONS
 
-// Returns a form for deleting the reports that the predicate marks as deletable.
+// Returns a form for deleting the reports that the predicate marks as deletable. A GET
+// request never processes a submission, regardless of its query string; only a POST
+// request (the form's own submission) does.
 export const reportDeletionForm = async (
   dirName: string,
   search: string,
+  method: string,
   deletionSpec: DeletionSpec
 ): Promise<{status: string; message?: string; answerPage?: string}> => {
   const {emptyIntro, failurePrefix, intro, isDeletable} = deletionSpec;
   const searchParams = new URLSearchParams(search);
   const authCode = searchParams?.get('authCode');
   const jobNames = searchParams?.getAll('report');
-  // If the form has been displayed by itself after a submission and any reports are to be deleted:
-  if (jobNames?.length) {
+  // If the form has been submitted and any reports are to be deleted:
+  if (method === 'POST' && jobNames?.length) {
     // If the authorization code is valid:
     if (authCode === process.env.AUTH_CODE) {
       try {
@@ -64,14 +67,16 @@ export const reportDeletionForm = async (
     }
     // Otherwise, i.e. if the authorization code is invalid:
     else {
-      // Report the error.
+      // Report the error, deliberately vague so as not to confirm to an attacker that the
+      // authorization code specifically (as opposed to some other part of the request) is
+      // what was wrong.
       return {
         status: 'error',
-        message: 'Invalid authorization code'
+        message: 'Invalid request'
       };
     }
   }
-  const reportNames = await fs.readdir(reportsPath());
+  const reportNames = await readdirOrCreate(reportsPath(), 'Reports directory');
   // Initialize an array of report summaries.
   const reportSpecs: ReportSpec[] = [];
   // For each report:

package/web/requestRetest/index.html

@@ -12,9 +12,9 @@
   </head>
   <body>
     <main>
-      <h1><a href="/">Kilotest</a>: Retest request received for __target__</h1>
-      <p>Your request to retest the __target__ page has been received.</p>
-      <p>The reason for your request has been recorded as <q>__why__</q>.</p>
+      <h1><a href="/">Kilotest</a>: Retest request received for __description__</h1>
+      <p>Your request to retest the __description__ page at __url__ has been received.</p>
+      <p>The reason for your request has been recorded as <q>__reason__</q>.</p>
       <p>Thank you for your request.</p>
       <p>If a <a href="/enqueueForm.html">Kilotest manager approves this request</a>, a test order will be added to the queue.</p>
       <p>In most cases, if you check Kilotest again in 1 day, you will find that the requested test has been performed.</p>

package/web/requestRetest/index.ts

@@ -5,27 +5,58 @@
 
 // IMPORTS
 
-import {getReportExtracts, processTestRequest} from '../../util.ts';
+import {populateTemplate, processTestRequest} from '../../util.ts';
 
 // FUNCTIONS
 
-export const answer = async (pageArgs: string, why: string) => {
-  const [timeStamp, jobID] = pageArgs.split('/');
-  // Get data on the latest available reports.
-  const reportExtracts = await getReportExtracts(true);
-  // Get data on the report whose page is to be retested.
-  const reportExtract = reportExtracts.find(
-    (extract) => extract.timeStamp === timeStamp && extract.jobID === jobID
-  );
-  // If no matching report was found:
-  if (!reportExtract) {
-    // Return why.
+export const answer = async (pageArgs: string, reason: string) => {
+  const [timeStamp, jobID] = pageArgs.split('/') as [string, string];
+  // Process the request. This resolves the cited report's description and URL itself.
+  const processResult = await processTestRequest(reason, {timeStamp, jobID});
+  // If the cited report does not exist:
+  if (processResult.result === 'nonreport') {
+    // Report this.
     return {
       status: 'error',
-      message: `No report found for ${timeStamp}-${jobID}`
+      message: 'Invalid request'
     };
   }
-  const {url, description} = reportExtract;
-  // Otherwise, i.e. if it succeeded, process the request.
-  return await processTestRequest('retest', import.meta.dirname, description, url, why);
+  const {result, description, url} = processResult;
+  // If the request was recorded:
+  if (result === 'ok') {
+    const query = {
+      description,
+      url,
+      reason
+    };
+    // Return the populated page.
+    return {
+      status: 'ok',
+      answerPage: await populateTemplate(import.meta.dirname, query)
+    };
+  }
+  // Otherwise, if the request is a duplicate:
+  else if (result === 'duplicate') {
+    // Report this.
+    return {
+      status: 'error',
+      message: 'Test request duplicates an already submitted request'
+    };
+  }
+  // Otherwise, if the cited report has been superseded:
+  else if (result === 'superseded') {
+    // Report this.
+    return {
+      status: 'error',
+      message: 'A later report about the page is already available'
+    }
+  }
+  // Otherwise, i.e. if a request to test a page with the same description or URL is approved:
+  else {
+    // Report this.
+    return {
+      status: 'error',
+      message: 'A request to test a page with the same description or URL is already approved'
+    }
+  }
 };

package/web/requestRetest/requestRetest.test.ts

@@ -68,11 +68,14 @@ test('answer returns ok with a populated answer page for a valid retest request'
   const result: any = 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.
+  // Verify the description and reason placeholders were replaced with the report target.
+  // (Note: the template's <title> uses __target__, a placeholder query never supplies;
+  // that pre-existing template mismatch is out of scope here and left unasserted.)
   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__'));
+  assert.ok(!result.answerPage.includes('__description__'));
+  assert.ok(!result.answerPage.includes('__url__'));
+  assert.ok(!result.answerPage.includes('__reason__'));
   // Verify the HTML is well-formed.
   const doc = parse(result.answerPage);
   const h1 = doc.querySelector('h1');
@@ -85,32 +88,43 @@ test('answer returns an error when the report does not exist', async () => {
   // Use a nonexistent report timestamp and jobID.
   const result: any = await answer('990101T0000/xxx', 'Because changes were made');
   assert.equal(result.status, 'error');
-  assert.ok(result.message?.includes('No report found'), `Expected no-report-found message, got: ${result.message}`);
+  assert.equal(result.message, 'Invalid request');
 });
 
-test('answer returns an error for an invalid retest request', async () => {
+test('answer returns an error for a duplicate retest request', async () => {
   const {answer} = await import('./index.ts');
-  // Use a valid report but a too-short reason.
-  const result = await answer('260101T0001/ct', 'why');
+  // Submit the same retest request twice; the second is a duplicate.
+  await answer('260101T0001/ct', 'Because changes were made');
+  const result: any = await answer('260101T0001/ct', 'Because changes were made');
   assert.equal(result.status, 'error');
-  assert.equal(result.message, 'Invalid request');
+  assert.equal(result.message, 'Test request duplicates an already submitted request');
 });
 
-test('answer returns an error when no extracts are available for the report', async (t) => {
-  // Mock getReportExtracts to return an empty array, delegating other exports.
-  // (getReportExtracts no longer returns error objects; reports not in the list
-  // are treated as not found.)
-  const realUtil = await import('../../util.ts');
-  t.mock.module('../../util.ts', {
-    exports: {
-      ...realUtil,
-      getReportExtracts: async () => []
-    }
-  } as any);
-  // Import a fresh instance of index.ts so it binds to the mocked module.
-  // The query string makes the specifier unique, bypassing the module cache.
-  const {answer} = await import('./index.ts?mockNoExtracts' as any);
-  const result: any = await answer('260101T0001/ct', 'Because changes were made');
+test('answer returns an error when the cited report has been superseded', async () => {
+  const {answer} = await import('./index.ts');
+  // 260101T0000-mix (Mixed Outcomes Page) is superseded by 260202T0000-new.
+  const result: any = await answer('260101T0000/mix', 'Because changes were made');
   assert.equal(result.status, 'error');
-  assert.ok(result.message?.includes('No report found'), `Expected no-report-found message, got: ${result.message}`);
+  assert.equal(result.message, 'A later report about the page is already available');
 });
+
+test('answer returns an error when a matching job is already claimed or queued', async () => {
+  const {answer} = await import('./index.ts');
+  // Create a claimed job sharing the description of the cited report
+  // (260101T0001-ct, "All CantTell Page").
+  const claimedDir = path.join(fixtureDBDir, 'jobs', 'claimed');
+  const jobPath = path.join(claimedDir, 'claimedJob.json');
+  await fs.writeFile(jobPath, JSON.stringify({
+    id: 'claimedJob',
+    target: {what: 'All CantTell Page', url: 'https://example.com/unrelated'}
+  }));
+  try {
+    const result: any = await answer('260101T0001/ct', 'Because changes were made');
+    assert.equal(result.status, 'error');
+    assert.equal(result.message, 'A request to test a page with the same description or URL is already approved');
+  }
+  finally {
+    await fs.unlink(jobPath).catch(() => {});
+  }
+});
+

package/web/requestTest/index.html

@@ -6,15 +6,15 @@
     <meta name="publisher" content="Jonathan Robert Pool">
     <meta name="creator" content="Jonathan Robert Pool">
     <meta name="keywords" content="report,accessibility,a11y">
-    <title>__target__ test request received | Kilotest</title>
+    <title>__description__ test request received | Kilotest</title>
     <link rel="icon" href="/favicon.ico">
     <link rel="stylesheet" href="/style.css">
   </head>
   <body>
     <main>
-      <h1><a href="/">Kilotest</a>: Test request received for __target__</h1>
-      <p>Your request to test the __target__ page has been received.</p>
-      <p>The reason for your request has been recorded as <q>__why__</q>.</p>
+      <h1><a href="/">Kilotest</a>: Test request received for __description__</h1>
+      <p>Your request to test the __description__ page at __url__ has been received.</p>
+      <p>The reason for your request has been recorded as <q>__reason__</q>.</p>
       <p>Thank you for your request.</p>
       <p>If a <a href="/enqueueForm.html">Kilotest manager approves this request</a>, a test order will be added to the queue.</p>
       <p>In most cases, if you check Kilotest again in 1 day, you will find that the requested job has been performed.</p>