@jrpool/kilotest 52.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/requestFeature.test.ts

@@ -81,9 +81,45 @@ test('requestFeature accepts a non-empty feature request and notifies the manage
   assert.ok(logged.some(line =>
     line.startsWith('WARNING (Kilotest: MCP feature request received)')
     && line.includes('Add a dark mode toggle')
+    // The alert reports the resulting queue size, so a maintainer who has been away can
+    // see at a glance how close the queue is to full.
+    && line.includes('Feature requests now awaiting review: 1 of 20')
   ));
 });
 
+test('requestFeature rejects a request with a fallback channel when the queue is full', async () => {
+  // Fill featureRequests.json with 20 distinct requests, reaching the cap.
+  const filler = Array.from({length: 20}, (_, i) => ({
+    timeStamp: '260101T0000', content: `Filler feature request number ${i}, long enough to pass the length check.`
+  }));
+  await fs.writeFile(process.env.FEATURE_REQUESTS_PATH!, JSON.stringify(filler));
+  const body = await response(['One feature request too many, long enough to pass the length check.']);
+  const details = body['response content']['details about your request'] as any;
+  assert.ok(details.error.includes('too many feature requests are awaiting review right now.'));
+  assert.ok(details.error.includes('https://github.com/jrpool/kilotest/issues'));
+  assert.ok(details.error.includes('info@kilotest.com'));
+  const featureRequests = JSON.parse(await fs.readFile(process.env.FEATURE_REQUESTS_PATH!, 'utf8'));
+  // The rejected request was not recorded.
+  assert.equal(featureRequests.length, 20);
+});
+
+test('requestFeature never rejects for a full inbox when FEATURE_REQUESTS_MAX is 0 (no limit)', async () => {
+  process.env.FEATURE_REQUESTS_MAX = '0';
+  try {
+    // Fill featureRequests.json past the default cap.
+    const filler = Array.from({length: 25}, (_, i) => ({
+      timeStamp: '260101T0000', content: `Filler feature request number ${i}, long enough to pass the length check.`
+    }));
+    await fs.writeFile(process.env.FEATURE_REQUESTS_PATH!, JSON.stringify(filler));
+    const body = await response(['One more feature request, long enough to pass the length check.']);
+    const details = body['response content']['details about your request'] as any;
+    assert.equal(details.error, undefined);
+  }
+  finally {
+    delete process.env.FEATURE_REQUESTS_MAX;
+  }
+});
+
 test('requestFeature includes tool name and metadata', async () => {
   const body = await response(['A sufficiently long feature description']);
   assert.equal(body['tool name'], 'requestFeature');

package/api/requestFeature.ts

@@ -8,7 +8,7 @@
 import {z} from 'zod';
 import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
 import {sendAlert} from '../alerts.ts';
-import {checkCommentDuplicate, checkLength, getJSON, getNowStamp} from '../util.ts';
+import {checkCommentDuplicate, checkLength, describeMax, getEnvMax, getJSON, getNowStamp} from '../util.ts';
 import {requestFeatureResponseSchema} from './schemas.ts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -21,6 +21,13 @@ type ResponseContent = z.infer<typeof requestFeatureResponseSchema>['response co
 // FUNCTIONS (helpers)
 
 const getFeatureRequestsPath = () => process.env.FEATURE_REQUESTS_PATH || path.join(import.meta.dirname, '../db/featureRequests.json');
+// Maximum number of feature requests held at once. Once reached, a new, distinct request
+// is rejected rather than stored, so the feature-requests file and the manager alert
+// emails it generates cannot grow without bound (modeled on a full mailbox rejecting new
+// mail; see GitHub issue #3, abuse type 3). Configurable via FEATURE_REQUESTS_MAX, since
+// different Kilotest deployments' maintainers may want a different size; a value of 0
+// means no limit.
+const getFeatureRequestsMax = () => getEnvMax('FEATURE_REQUESTS_MAX', 20);
 
 // FUNCTIONS
 
@@ -61,7 +68,18 @@ export const response = async (args: string[]) => {
         }
       };
     }
-    // Otherwise, i.e. if it is not a duplicate:
+    // Otherwise, if the feature requests already on file have reached the cap (a cap of 0
+    // means no limit, so the queue is never full):
+    else if (getFeatureRequestsMax() > 0 && featureRequests.length >= getFeatureRequestsMax()) {
+      responseContent = {
+        'details about your request': {
+          error: 'request invalid: too many feature requests are awaiting review right now. ' +
+            'Please try again later, or post your request at https://github.com/jrpool/kilotest/issues ' +
+            'or email info@kilotest.com.'
+        }
+      };
+    }
+    // Otherwise, i.e. if it is not a duplicate and the queue is not full:
     else {
       // Record the feature request alongside the existing ones.
       featureRequests.push({
@@ -70,8 +88,12 @@ export const response = async (args: string[]) => {
       });
       await fs.mkdir(path.dirname(featureRequestsPath), {recursive: true});
       await fs.writeFile(featureRequestsPath, getJSON(featureRequests));
-      // Notify the manager.
-      await sendAlert('Kilotest: MCP feature request received', feature);
+      // Notify the manager, including the resulting count, so a maintainer who has been
+      // away sees at a glance how urgently the requests need review.
+      await sendAlert(
+        'Kilotest: MCP feature request received',
+        `${feature}\nFeature requests now awaiting review: ${featureRequests.length} of ${describeMax(getFeatureRequestsMax())}`
+      );
       // Add the disposition to the response content.
       responseContent = {
         'details about your request': {

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,59 +55,75 @@ 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 an already-tested page', async () => {
+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 {
+    const body = await response(['Redirecting Page', 'https://example.com/redirector', '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('WARNING (Kilotest: request rejected for redirecting to a disallowed target)')
+      && line.includes('https://example.com/redirector')
+    ));
+  } finally {
+    process.env.ALLOW_INTERNAL_TARGETS = 'true';
+  }
+});
+
+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'}
@@ -127,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'}
@@ -147,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;
@@ -156,21 +172,39 @@ 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
+    // see at a glance how close the queue is to full.
+    && line.includes('Requests now awaiting approval: 1 of 20')
   ));
 });
 
-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('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.'
+  }));
+  await fs.writeFile(testRequestsPath, JSON.stringify({'https://example.com/filler': filler}));
+  const body = await response(['One Too Many Page', 'https://example.com/one-too-many', 'A reason that is long enough.']);
+  const details = body['response content']['details about your request'] as any;
+  assert.equal(details.error, undefined);
+  const disposition = body['response content']['disposition of your request'] as any;
+  assert.ok(disposition['what happens next'].includes('too many requests are awaiting approval right now.'));
+  assert.ok(disposition['what happens next'].includes('https://github.com/jrpool/kilotest/issues'));
+  assert.ok(disposition['what happens next'].includes('info@kilotest.com'));
+});