@jrpool/kilotest 55.0.0 → 57.0.1

package/api/orderRetest.test.ts

@@ -0,0 +1,179 @@
+/*
+  orderRetest.test.ts
+  Tests for api/orderRetest.ts using the fixture corpus.
+*/
+
+// IMPORTS
+
+import {test, before, beforeEach, after} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {fixtureDBDir} from '../test/dbFixture.ts';
+
+for (const key of ['MANAGER_EMAIL', 'ALERT_API_HOST', 'ALERT_API_PATH', 'ALERT_API_KEY', 'ALERT_FROM']) {
+  process.env[key] = '';
+}
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+const queuePath = path.join(fixtureDBDir, 'jobs', 'queue');
+// A report added only to this test's disposable copy of the fixture database (never to
+// the tracked test/fixtures/db corpus), matching the fixture requestRetest.test.ts uses
+// for the same reason: a 3-character job ID satisfying isJobID without perturbing
+// report-count tests elsewhere that copy the whole corpus.
+const retestFixturePath = path.join(fixtureDBDir, 'reports', '260101T0004-ord.json');
+const retestFixtureReport = {
+  id: '260101T0004-ord',
+  what: 'Order Retest Fixture Page',
+  target: {what: 'Order Retest Fixture Page', url: 'https://example.com/orderretestfixture'},
+  sources: {worker: 'test-worker'},
+  acts: [],
+  jobData: {startTime: '26-01-01T00:00', endTime: '26-01-01T00:10', elapsedSeconds: 600, preventions: {}, issuelessRules: []},
+  catalog: {},
+  images: {},
+  checkpoints: []
+};
+
+before(async () => {
+  process.env.DB_DIR = fixtureDBDir;
+  await fs.writeFile(retestFixturePath, JSON.stringify(retestFixtureReport));
+});
+
+beforeEach(async () => {
+  for (const fileName of await fs.readdir(queuePath)) {
+    await fs.unlink(path.join(queuePath, fileName));
+  }
+});
+
+import {response} from './orderRetest.ts';
+
+after(async () => {
+  await fs.unlink(retestFixturePath);
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('orderRetest rejects a nonexistent report', async () => {
+  const body = await response(['251231T0000', 'zzz', 'A reason that is long enough.']);
+  const details = body['response content']['details about your order'] as any;
+  assert.ok(details.error.includes('does not exist'));
+});
+
+test('orderRetest rejects a malformed timestamp or job identifier', async () => {
+  const body = await response(['999999T9999', 'xyz', 'A reason that is long enough.']);
+  const details = body['response content']['details about your order'] as any;
+  assert.ok(details.error.includes('malformed'));
+});
+
+test('orderRetest rejects a reason shorter than 20 characters', async () => {
+  const body = await response(['260101T0004', 'ord', 'short']);
+  const details = body['response content']['details about your order'] as any;
+  assert.ok(details.error.includes('reason'));
+});
+
+test('orderRetest rejects a reason longer than 100 characters', async () => {
+  const longReason = 'x'.repeat(101);
+  const body = await response(['260101T0004', 'ord', longReason]);
+  const details = body['response content']['details about your order'] as any;
+  assert.ok(details.error.includes('reason'));
+});
+
+test('orderRetest rejects a superseded report', async () => {
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // so it is superseded.
+  const body = await response(['260101T0000', 'mix', 'A reason that is long enough.']);
+  const details = body['response content']['details about your order'] as any;
+  assert.equal(details.error, undefined);
+  const disposition = body['response content']['disposition of your order'] as any;
+  assert.ok(
+    disposition['what happens next'].includes('a later report about a page with the same description is available.')
+  );
+  assert.equal(disposition['report identifier'], null);
+});
+
+test('orderRetest rejects a report matching a claimed job by description', async () => {
+  const claimedPath = path.join(fixtureDBDir, 'jobs', 'claimed', 'clm.json');
+  await fs.writeFile(claimedPath, JSON.stringify({
+    target: {what: 'Order Retest Fixture Page', url: 'https://example.com/unrelated'}
+  }));
+  try {
+    const body = await response(['260101T0004', 'ord', 'A reason that is long enough.']);
+    const details = body['response content']['details about your order'] as any;
+    assert.equal(details.error, undefined);
+    const disposition = body['response content']['disposition of your order'] as any;
+    assert.ok(
+      disposition['what happens next']
+      .includes('a request to test a page with the same description is already approved.')
+    );
+  }
+  finally {
+    await fs.unlink(claimedPath);
+  }
+});
+
+test('orderRetest rejects a report matching a queued job by URL', async () => {
+  const queuedFilePath = path.join(queuePath, 'que.json');
+  await fs.writeFile(queuedFilePath, JSON.stringify({
+    target: {what: 'Some Other Page', url: 'https://example.com/orderretestfixture'}
+  }));
+  try {
+    const body = await response(['260101T0004', 'ord', 'A reason that is long enough.']);
+    const details = body['response content']['details about your order'] as any;
+    assert.equal(details.error, undefined);
+    const disposition = body['response content']['disposition of your order'] as any;
+    assert.ok(
+      disposition['what happens next']
+      .includes('a request to test a page with the same URL is already approved.')
+    );
+  }
+  finally {
+    await fs.unlink(queuedFilePath);
+  }
+});
+
+test('orderRetest rejects an order once the job queue is full', async () => {
+  const fillerPath = path.join(queuePath, 'fil.json');
+  await fs.writeFile(fillerPath, JSON.stringify({target: {what: 'Filler', url: 'https://example.com/filler'}}));
+  process.env.JOB_QUEUE_MAX = '1';
+  try {
+    const body = await response(['260101T0004', 'ord', 'A reason that is long enough.']);
+    const details = body['response content']['details about your order'] as any;
+    assert.equal(details.error, undefined);
+    const disposition = body['response content']['disposition of your order'] as any;
+    assert.ok(disposition['what happens next'].includes('too many requests are awaiting approval right now.'));
+  } finally {
+    delete process.env.JOB_QUEUE_MAX;
+    await fs.unlink(fillerPath);
+  }
+});
+
+test('orderRetest accepts a valid retest order and enqueues a job directly', async () => {
+  const body = await response(['260101T0004', 'ord', 'A reason that is long enough.']);
+  const details = body['response content']['details about your order'] as any;
+  assert.equal(details.error, undefined);
+  assert.equal(details['page to be retested'].description, 'Order Retest Fixture Page');
+  const disposition = body['response content']['disposition of your order'] as any;
+  assert.ok(disposition['report identifier']);
+  assert.ok(disposition['what happens next'].includes('Testing has begun.'));
+  assert.ok(disposition['do you want to wait for completion'].includes('awaitTest'));
+  const queuedFiles = await fs.readdir(queuePath);
+  assert.equal(queuedFiles.length, 1);
+  const job = JSON.parse(await fs.readFile(path.join(queuePath, queuedFiles[0]!), 'utf8'));
+  assert.equal(job.target.what, 'Order Retest Fixture Page');
+  assert.equal(job.sources.reason, 'A reason that is long enough.');
+});
+
+test('orderRetest response omits a web UI URL for this request but includes the ancestor', async () => {
+  const body = await response(['260101T0004', 'ord', 'A reason that is long enough.']);
+  const similarWeb = body['URLs of similar requests for web users'] as any;
+  assert.equal(similarWeb['this request'], null);
+  assert.ok(similarWeb['closest ancestor request'].includes('listIssues.html'));
+});

package/api/orderRetest.ts

@@ -0,0 +1,119 @@
+/*
+  orderRetest.ts
+  Processes an order to retest a page immediately, without manual approval, and returns an acknowledgement.
+*/
+
+// IMPORTS
+
+import {z} from 'zod';
+import {getRequestFailureReason, getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
+import {checkLength, isJobID, isTimeStamp, orderJob} from '../util.ts';
+import {orderRetestResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof orderRetestResponseSchema>['response content'];
+
+// FUNCTIONS
+
+// Returns the response body.
+export const response = async (args: string[]) => {
+  const [timeStamp = '', jobID = '', reason = ''] = args;
+  const thisHost = getThisHost();
+  const reasonCheck = checkLength(reason, 20, 100, 'reason');
+  // Initialize the response-content properties.
+  let requestDetails: ResponseContent['details about your order'];
+  let requestDisposition: ResponseContent['disposition of your order'] = null;
+  // If the timestamp or job ID is not syntactically valid:
+  if (!isTimeStamp(timeStamp) || !isJobID(jobID)) {
+    requestDetails = {
+      error: 'order invalid: the report timestamp or job identifier is malformed'
+    };
+  }
+  // Otherwise, if the encoded reason is too short or too long:
+  else if (reasonCheck.status === 'error') {
+    requestDetails = {
+      error: `order invalid: your ${reasonCheck.message}`
+    };
+  }
+  // Otherwise, i.e. if the order is facially valid:
+  else {
+    // Order the retest. Unlike processTestRequest, this enqueues the job directly, with
+    // no manual-approval step, gated only by the lightweight checks orderJob itself
+    // performs (the target is not already claimed or queued, and the job queue is not
+    // already full). This resolves the cited report's description and URL itself.
+    const orderResult = await orderJob({timeStamp, jobID}, reason);
+    // If the cited report does not exist:
+    if (orderResult.result === 'nonreport') {
+      requestDetails = {
+        error: 'order invalid: the specified report does not exist'
+      };
+    }
+    // Otherwise, i.e. if the cited report was found:
+    else {
+      // Add details about the order.
+      requestDetails = {
+        'date and time received': new Date().toISOString(),
+        'page to be retested': {
+          description: orderResult.description,
+          URL: orderResult.url
+        },
+        'reason why the page should be retested': reason
+      };
+      // Add information about the disposition of the order.
+      if (orderResult.result === 'ok') {
+        const [reportTimeStamp, reportJobID] = orderResult.jobID.split('-') as [string, string];
+        requestDisposition = {
+          'what happens next': 'Testing has begun. Once it finishes, the report will be available via the listIssues tool.',
+          'report identifier': {timeStamp: reportTimeStamp, jobID: reportJobID},
+          'how you can check for completion': `Call the listIssues tool with timeStamp "${reportTimeStamp}" and jobID "${reportJobID}" to learn whether the report is ready.`,
+          'do you want to wait for completion': 'Testing typically takes about 2 minutes and occasionally up to 4 minutes. Do you want to wait (and be notified of completion) instead of checking back later? If so, call the awaitTest tool with the same timeStamp and jobID.'
+        };
+      }
+      else {
+        requestDisposition = {
+          'what happens next': `Your order will not be processed, because ${getRequestFailureReason(
+            orderResult.result,
+            {result: 'superseded', reason: 'a later report about a page with the same description is available.'}
+          )}`,
+          'report identifier': null,
+          'how you can check for completion': 'Not applicable.',
+          'do you want to wait for completion': 'Not applicable.'
+        };
+      }
+    }
+  }
+  // Create the response content.
+  const responseContent: ResponseContent = {
+    'details about your order': requestDetails,
+    'disposition of your order': requestDisposition
+  };
+  // Create a response body.
+  const body = {
+    'tool collection': getToolsFacts(),
+    'tool name': 'orderRetest',
+    'this request': {
+      description: 'Process my order to retest a page, immediately and without manual approval. The timeStamp and jobID parameters identify the latest available report about the page. Those parameters were in the response to my earlier listIssues request. The reason property of the request body is the reason why the page should be retested.',
+      method: 'POST',
+      URL: `${thisHost}/api/orderRetest/${timeStamp}/${jobID}`,
+      body: {
+        reason
+      },
+      'closest ancestor request': {
+        'tool name': 'listIssues',
+        description: 'Provide details about one report, including basics about the issues reported in it.',
+        method: 'GET',
+        URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`
+      }
+    },
+    'URLs of similar requests for web users': {
+      'this request': null,
+      'closest ancestor request': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+    },
+    'response metadata': getResponseMetadata(),
+    'response content': responseContent
+  };
+  // Return it.
+  return body;
+};

package/api/{requestTest.test.ts → requestNewTest.test.ts}

@@ -1,6 +1,6 @@
 /*
-  requestTest.test.ts
-  Tests for api/requestTest.ts using the fixture corpus.
+  requestNewTest.test.ts
+  Tests for api/requestNewTest.ts using the fixture corpus.
 */
 
 // IMPORTS
@@ -11,7 +11,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import {fixtureDBDir} from '../test/dbFixture.ts';
 
-// Blank the alert configuration unconditionally, before ./requestTest.ts (whose
+// Blank the alert configuration unconditionally, before ./requestNewTest.ts (whose
 // processTestRequest calls sendAlert) is ever imported below, so this file sends no
 // real alert emails even when run directly rather than via `npm test`.
 for (const key of ['MANAGER_EMAIL', 'ALERT_API_HOST', 'ALERT_API_PATH', 'ALERT_API_KEY', 'ALERT_FROM']) {
@@ -41,7 +41,7 @@ beforeEach(async () => {
   console.log = (...args) => logged.push(args.join(' '));
 });
 
-import {response} from './requestTest.ts';
+import {response} from './requestNewTest.ts';
 
 after(() => {
   console.log = originalLog;
@@ -55,45 +55,45 @@ after(() => {
 
 // TESTS
 
-test('requestTest rejects an empty description', async () => {
+test('requestNewTest rejects an empty description', async () => {
   const body = await response(['', 'https://example.com/test', 'A reason that is long enough.']);
   assert.ok((body['response content']['details about your request'] as any).error);
-  assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });
 
-test('requestTest rejects a description longer than 100 characters', async () => {
+test('requestNewTest rejects a description longer than 100 characters', async () => {
   const longWhat = 'x'.repeat(101);
   const body = await response([longWhat, 'https://example.com/test', 'A reason that is long enough.']);
   assert.ok((body['response content']['details about your request'] as any).error);
-  assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });
 
-test('requestTest rejects a URL shorter than 12 characters', async () => {
+test('requestNewTest rejects a URL shorter than 12 characters', async () => {
   const body = await response(['Test Page', 'short', 'A reason that is long enough.']);
   assert.ok((body['response content']['details about your request'] as any).error);
-  assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });
 
-test('requestTest rejects a syntactically invalid URL with the correct length', async () => {
+test('requestNewTest rejects a syntactically invalid URL with the correct length', async () => {
   const body = await response(['Test Page', 'not-a-valid-url', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('invalid URL'));
-  assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });
 
-test('requestTest rejects a private-address URL unless internal targets are allowed', async () => {
+test('requestNewTest rejects a private-address URL unless internal targets are allowed', async () => {
   delete process.env.ALLOW_INTERNAL_TARGETS;
   try {
     const body = await response(['Internal Page', 'https://192.168.1.1/page', 'A reason that is long enough.']);
     const details = body['response content']['details about your request'] as any;
     assert.ok(details.error.includes('does not resolve to a page that this deployment can test'));
-    assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+    assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
   } finally {
     process.env.ALLOW_INTERNAL_TARGETS = 'true';
   }
 });
 
-test('requestTest rejects a URL that redirects to a disallowed target, and alerts a manager', async (t) => {
+test('requestNewTest rejects a URL that redirects to a disallowed target, and alerts a manager', async (t) => {
   delete process.env.ALLOW_INTERNAL_TARGETS;
   t.mock.method(globalThis, 'fetch', async () => ({url: 'https://10.0.0.5/page'}) as Response);
   try {
@@ -109,21 +109,21 @@ test('requestTest rejects a URL that redirects to a disallowed target, and alert
   }
 });
 
-test('requestTest rejects an already-tested page', async () => {
+test('requestNewTest rejects an already-tested page', async () => {
   const body = await response(['Mixed Outcomes Page', 'https://example.com/mixed', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   // A report for this description and URL already exists, so processTestRequest
-  // returns 'retest' and the failure is reported via the disposition, not details.error.
+  // returns 'reportExists' and the failure is reported via the disposition, not details.error.
   assert.equal(details.error, undefined);
   const disposition = body['response content']['disposition of your request'] as any;
   assert.ok(
     disposition['what happens next']
     .includes('a report about a page with the same description and URL is available.')
   );
-  assert.ok(!logged.some(line => line.includes('new test request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a new test awaits approval')));
 });
 
-test('requestTest rejects a page matching a claimed job by description', async () => {
+test('requestNewTest rejects a page matching a claimed job by description', async () => {
   const claimedPath = path.join(fixtureDBDir, 'jobs', 'claimed', 'clm.json');
   await fs.writeFile(claimedPath, JSON.stringify({
     target: {what: 'Claimed Test Page', url: 'https://example.com/claimed-job'}
@@ -143,7 +143,7 @@ test('requestTest rejects a page matching a claimed job by description', async (
   }
 });
 
-test('requestTest rejects a page matching a queued job by URL', async () => {
+test('requestNewTest rejects a page matching a queued job by URL', async () => {
   const queuedPath = path.join(fixtureDBDir, 'jobs', 'queue', 'que.json');
   await fs.writeFile(queuedPath, JSON.stringify({
     target: {what: 'Some Other Page', url: 'https://example.com/queued-url'}
@@ -163,7 +163,7 @@ test('requestTest rejects a page matching a queued job by URL', async () => {
   }
 });
 
-test('requestTest rejects a duplicate request', async () => {
+test('requestNewTest rejects a duplicate request', async () => {
   await response(['Duplicate API Page', 'https://example.com/dup-api', 'A reason that is long enough.']);
   const body = await response(['Duplicate API Page', 'https://example.com/dup-api', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
@@ -172,13 +172,13 @@ test('requestTest rejects a duplicate request', async () => {
   assert.ok(disposition['what happens next'].includes('an identical request is already awaiting approval.'));
 });
 
-test('requestTest accepts a valid new page request', async () => {
+test('requestNewTest accepts a valid new page request', async () => {
   const body = await response(['Brand New Page', 'https://example.com/brandnew', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.equal(details.error, undefined);
   assert.equal(details['page to be tested'].description, 'Brand New Page');
   assert.ok(logged.some(line =>
-    line.startsWith('WARNING (Kilotest: new test request awaits approval)')
+    line.startsWith('WARNING (Kilotest: request for a new test awaits approval)')
     && line.includes('Brand New Page')
     && line.includes('https://example.com/brandnew')
     // The alert reports the resulting queue size, so a maintainer who has been away can
@@ -187,14 +187,14 @@ test('requestTest accepts a valid new page request', async () => {
   ));
 });
 
-test('requestTest includes disposition information for a valid request', async () => {
+test('requestNewTest includes disposition information for a valid request', async () => {
   const body = await response(['Brand New Page', 'https://example.com/brandnew', 'A reason that is long enough.']);
   const disposition = body['response content']['disposition of your request'];
   assert.ok(disposition);
   assert.ok(disposition['what happens next']);
 });
 
-test('requestTest rejects a request with a fallback channel when the queue is full', async () => {
+test('requestNewTest rejects a request with a fallback channel when the queue is full', async () => {
   // Fill testRequests.json with 20 pending requests, all for one URL, to reach the cap.
   const filler = Array.from({length: 20}, (_, i) => ({
     timeStamp: '260101T0000', description: `Filler Page ${i}`, reason: 'Filler reason.'

package/api/{requestTest.ts → requestNewTest.ts}

@@ -1,20 +1,20 @@
 /*
-  requestTest.ts
+  requestNewTest.ts
   Processes a request to test an untested page and returns an acknowledgement.
 */
 
 // IMPORTS
 
 import {z} from 'zod';
-import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
+import {buildRequestDisposition, getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
 import {checkLength, isAllowedRedirectTarget, isAllowedTarget, isURL, processTestRequest} from '../util.ts';
-import {requestTestResponseSchema} from './schemas.ts';
+import {requestNewTestResponseSchema} from './schemas.ts';
 import {sendAlert} from '../alerts.ts';
 
 // TYPES
 
 // The response content defined by the response schema.
-type ResponseContent = z.infer<typeof requestTestResponseSchema>['response content'];
+type ResponseContent = z.infer<typeof requestNewTestResponseSchema>['response content'];
 
 // FUNCTIONS
 
@@ -77,38 +77,15 @@ export const response = async (args: string[]) => {
       'reason why the page should be tested': reason
     };
     // Add information about the disposition of the request.
-    if (requestResult === 'ok') {
-      requestDisposition = {
-        'what happens next': 'Your request is likely to be approved and processed within 1 hour to 1 day.',
-        'how you can check for completion': 'You can call the listReports tool to learn whether the page has been tested and a report is available.',
-        'how a web user can check for completion': `A web user can visit ${thisHost}/listReports.html to learn whether the page has been tested and a report is available.`
-      };
-    }
-    else {
-      const failureFact = 'Your request will not be processed, because ';
-      let failureReason: string;
-      if (requestResult === 'description') {
-        failureReason = 'a request to test a page with the same description is already approved.'
-      }
-      else if (requestResult === 'url') {
-        failureReason = 'a request to test a page with the same URL is already approved.'
-      }
-      else if (requestResult === 'retest') {
-        failureReason = 'a report about a page with the same description and URL is available.'
-      }
-      else if (requestResult === 'queueFull') {
-        failureReason = 'too many requests are awaiting approval right now. Please try again later, ' +
-          'or post your request at https://github.com/jrpool/kilotest/issues or email info@kilotest.com.'
-      }
-      else {
-        failureReason = 'an identical request is already awaiting approval.'
-      }
-      requestDisposition = {
-        'what happens next': `${failureFact}${failureReason}`,
-        'how you can check for completion': 'Not applicable.',
-        'how a web user can check for completion': 'Not applicable.'
-      }
-    }
+    requestDisposition = buildRequestDisposition(
+      requestResult,
+      {
+        whatHappensNext: 'Your request is likely to be approved and processed within 1 hour to 1 day.',
+        howToCheck: 'You can call the listReports tool to learn whether the page has been tested and a report is available.',
+        howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been tested and a report is available.`
+      },
+      {result: 'reportExists', reason: 'a report about a page with the same description and URL is available.'}
+    );
   }
   // Create the response content.
   const responseContent: ResponseContent = {
@@ -118,11 +95,11 @@ export const response = async (args: string[]) => {
   // Create a response body.
   const body = {
     'tool collection': getToolsFacts(),
-    'tool name': 'requestTest',
+    'tool name': 'requestNewTest',
     'this request': {
       description: 'Process my request to test a page about which no report is available yet. I have provided a description and the URL of the page and a reason why it should be tested.',
       method: 'POST',
-      URL: `${thisHost}/api/requestTest`,
+      URL: `${thisHost}/api/requestNewTest`,
       body: {
         description,
         URL: url,
@@ -136,7 +113,7 @@ export const response = async (args: string[]) => {
       }
     },
     'URLs of similar requests for web users': {
-      'this request': `${thisHost}/requestTestForm.html`,
+      'this request': `${thisHost}/requestNewTestForm.html`,
       'closest ancestor request': `${thisHost}/listReports.html`
     },
     'response metadata': getResponseMetadata(),

package/api/requestRetest.test.ts

@@ -74,14 +74,14 @@ test('requestRetest rejects a nonexistent report', async () => {
   const body = await response(['251231T0000', 'zzz', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('does not exist'));
-  assert.ok(!logged.some(line => line.includes('new retest request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a retest awaits approval')));
 });
 
 test('requestRetest rejects a malformed timestamp or job identifier', async () => {
   const body = await response(['999999T9999', 'xyz', 'A reason that is long enough.']);
   const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('malformed'));
-  assert.ok(!logged.some(line => line.includes('new retest request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a retest awaits approval')));
 });
 
 test('requestRetest rejects a superseded report', async () => {
@@ -95,14 +95,14 @@ test('requestRetest rejects a superseded report', async () => {
   assert.ok(
     disposition['what happens next'].includes('a later report about a page with the same description is available.')
   );
-  assert.ok(!logged.some(line => line.includes('new retest request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a retest awaits approval')));
 });
 
 test('requestRetest rejects a reason shorter than 20 characters', async () => {
   const body = await response(['260101T0003', 'ret', 'short']);
   const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('reason'));
-  assert.ok(!logged.some(line => line.includes('new retest request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a retest awaits approval')));
 });
 
 test('requestRetest rejects a reason longer than 100 characters', async () => {
@@ -110,7 +110,7 @@ test('requestRetest rejects a reason longer than 100 characters', async () => {
   const body = await response(['260101T0003', 'ret', longReason]);
   const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('reason'));
-  assert.ok(!logged.some(line => line.includes('new retest request awaits approval')));
+  assert.ok(!logged.some(line => line.includes('request for a retest awaits approval')));
 });
 
 test('requestRetest rejects a report matching a claimed job by description', async () => {
@@ -170,7 +170,7 @@ test('requestRetest accepts a valid retest request for the latest report of a pa
   assert.equal(details.error, undefined);
   assert.equal(details['page to be retested'].description, 'Mixed Outcomes Page');
   assert.ok(logged.some(line =>
-    line.startsWith('WARNING (Kilotest: new retest request awaits approval)')
+    line.startsWith('WARNING (Kilotest: request for a retest awaits approval)')
     && line.includes('Mixed Outcomes Page')
     && line.includes('https://example.com/mixed')
     // The alert reports the resulting queue size, so a maintainer who has been away can