@jrpool/kilotest 55.0.0 → 57.0.1

package/util.test.ts

@@ -21,6 +21,7 @@ for (const key of ['MANAGER_EMAIL', 'ALERT_API_HOST', 'ALERT_API_PATH', 'ALERT_A
 
 import {
   annotateReportObject,
+  awaitJob,
   checkCommentDuplicate,
   checkCommentLength,
   checkLength,
@@ -66,6 +67,7 @@ import {
   makeBreakable,
   minifyURL,
   objectSort,
+  orderJob,
   processTestRequest,
   testRequestsLock,
   testRequestsPath,
@@ -888,12 +890,12 @@ test('processTestRequest returns a duplicate error for a repeated request', {tim
   await fs.writeFile(testRequestsPath(), '{}\n');
 });
 
-test('processTestRequest returns a retest error when a report already exists for the page', async () => {
+test('processTestRequest returns a reportExists error when a report already exists for the page', async () => {
   // The fixture database already has a report for this description and URL.
   const {result} = await processTestRequest(
     'because accessibility', {description: 'Mixed Outcomes Page', url: 'https://example.com/mixed'}
   );
-  assert.equal(result, 'retest');
+  assert.equal(result, 'reportExists');
 });
 
 test('processTestRequest returns a queueFull error once the pending-request queue is full', {timeout: 500}, async () => {
@@ -1852,3 +1854,213 @@ test('getMetrics backfills every category, and generates a since stamp, from a b
     fsSync.rmSync(tmpDir, {recursive: true});
   }
 });
+
+// TESTS FOR orderJob AND awaitJob (GitHub issue #111)
+
+test('orderJob enqueues a new-page order directly into the job queue', async () => {
+  const {result, description, url, jobID} = await orderJob(
+    {description: 'Ordered Page', url: 'https://example.com/ordered'}, 'because accessibility matters here'
+  ) as any;
+  assert.equal(result, 'ok');
+  assert.equal(description, 'Ordered Page');
+  assert.equal(url, 'https://example.com/ordered');
+  assert.match(jobID, /^\d{6}T\d{4}-[a-z0-9]{3}$/);
+  const queuedPath = path.join(jobsPath(), 'queue', `${jobID}.json`);
+  try {
+    const job = JSON.parse(await fs.readFile(queuedPath, 'utf8'));
+    assert.equal(job.target.what, 'Ordered Page');
+    assert.equal(job.target.url, 'https://example.com/ordered');
+    assert.equal(job.sources.reason, 'because accessibility matters here');
+    // No pending-approval inbox entry is created; the job goes straight to the queue.
+    const testRequests = JSON.parse(await fs.readFile(testRequestsPath(), 'utf8'));
+    assert.equal(testRequests['https://example.com/ordered'], undefined);
+  }
+  finally {
+    await fs.unlink(queuedPath);
+  }
+});
+
+test('orderJob returns a reportExists error when a report already exists for the ordered page', async () => {
+  const {result} = await orderJob(
+    {description: 'Mixed Outcomes Page', url: 'https://example.com/mixed'}, 'because accessibility matters here'
+  );
+  assert.equal(result, 'reportExists');
+});
+
+test('orderJob returns "description" for a page matching a claimed job by description', async () => {
+  const claimedPath = path.join(jobsPath(), 'claimed', 'clm.json');
+  await fs.writeFile(claimedPath, getJSON({
+    target: {what: 'Claimed Order Page', url: 'https://example.com/claimed-order-job'}
+  }));
+  try {
+    const {result} = await orderJob(
+      {description: 'Claimed Order Page', url: 'https://example.com/some-other-order-url'},
+      'because accessibility matters here'
+    );
+    assert.equal(result, 'description');
+  }
+  finally {
+    await fs.unlink(claimedPath);
+  }
+});
+
+test('orderJob returns "url" for a page matching a queued job by URL', async () => {
+  const queuedPath = path.join(jobsPath(), 'queue', 'que.json');
+  await fs.writeFile(queuedPath, getJSON({
+    target: {what: 'Some Queued Order Page', url: 'https://example.com/queued-order-url'}
+  }));
+  try {
+    const {result} = await orderJob(
+      {description: 'A Different Order Page', url: 'https://example.com/queued-order-url'},
+      'because accessibility matters here'
+    );
+    assert.equal(result, 'url');
+  }
+  finally {
+    await fs.unlink(queuedPath);
+  }
+});
+
+test('orderJob throws when a job file in a category directory is defective', async () => {
+  const claimedPath = path.join(jobsPath(), 'claimed', 'bad.json');
+  await fs.writeFile(claimedPath, 'not valid json');
+  try {
+    await assert.rejects(
+      orderJob({description: 'Any Order Page', url: 'https://example.com/any-order'}, 'because accessibility matters here'),
+      /Failed to order test/
+    );
+  }
+  finally {
+    await fs.unlink(claimedPath);
+  }
+});
+
+test('orderJob returns "nonreport" when a retest order cites a report that does not exist', async () => {
+  const {result} = await orderJob({timeStamp: '999999T9999', jobID: 'xxx'}, 'because accessibility matters here');
+  assert.equal(result, 'nonreport');
+});
+
+test('orderJob returns "superseded" when a retest order cites a superseded report', async () => {
+  // 260101T0000-mix is an earlier report of "Mixed Outcomes Page" than 260202T0000-new,
+  // so it is superseded.
+  const {result} = await orderJob(
+    {timeStamp: '260101T0000', jobID: 'mix'}, 'because accessibility matters here'
+  );
+  assert.equal(result, 'superseded');
+});
+
+test('orderJob enqueues a retest order for the latest report of a page', async () => {
+  const {result, description, url, jobID} = await orderJob(
+    {timeStamp: '260202T0000', jobID: 'new'}, 'because accessibility matters here'
+  ) as any;
+  assert.equal(result, 'ok');
+  assert.equal(description, 'Mixed Outcomes Page');
+  assert.equal(url, 'https://example.com/mixed');
+  const queuedPath = path.join(jobsPath(), 'queue', `${jobID}.json`);
+  try {
+    const job = JSON.parse(await fs.readFile(queuedPath, 'utf8'));
+    assert.equal(job.target.what, 'Mixed Outcomes Page');
+  }
+  finally {
+    await fs.unlink(queuedPath);
+  }
+});
+
+test('orderJob honors JOB_QUEUE_MAX when the cap is reached', async () => {
+  process.env.JOB_QUEUE_MAX = '1';
+  const fillerPath = path.join(jobsPath(), 'queue', 'fil.json');
+  await fs.writeFile(fillerPath, getJSON({target: {what: 'Filler Queued Page', url: 'https://example.com/filler-queued'}}));
+  try {
+    const {result} = await orderJob(
+      {description: 'One Too Many Order Page', url: 'https://example.com/one-too-many-order'},
+      'because accessibility matters here'
+    );
+    assert.equal(result, 'queueFull');
+  }
+  finally {
+    delete process.env.JOB_QUEUE_MAX;
+    await fs.unlink(fillerPath);
+  }
+});
+
+test('orderJob never returns queueFull when JOB_QUEUE_MAX is 0 (no limit)', async () => {
+  process.env.JOB_QUEUE_MAX = '0';
+  const fillerPath = path.join(jobsPath(), 'queue', 'fi2.json');
+  await fs.writeFile(fillerPath, getJSON({target: {what: 'Filler Queued Page Two', url: 'https://example.com/filler-queued-2'}}));
+  try {
+    const {result, jobID} = await orderJob(
+      {description: 'One More Order Page', url: 'https://example.com/one-more-order'},
+      'because accessibility matters here'
+    ) as any;
+    assert.equal(result, 'ok');
+    await fs.unlink(path.join(jobsPath(), 'queue', `${jobID}.json`));
+  }
+  finally {
+    delete process.env.JOB_QUEUE_MAX;
+    await fs.unlink(fillerPath);
+  }
+});
+
+test('awaitJob returns "completed" immediately when a report already exists', async () => {
+  const outcome = await awaitJob('260101T0000', 'mix');
+  assert.equal(outcome, 'completed');
+});
+
+test('awaitJob returns "notFound" for an identifier naming neither a report nor a pending job', async () => {
+  const outcome = await awaitJob('999999T9999', 'xxx');
+  assert.equal(outcome, 'notFound');
+});
+
+test('awaitJob returns "failed" when the job has moved to the failed directory', async () => {
+  const failedPath = path.join(jobsPath(), 'failed', '260101T1111-flj.json');
+  await fs.mkdir(path.dirname(failedPath), {recursive: true});
+  await fs.writeFile(failedPath, getJSON({target: {what: 'Failed Await Page', url: 'https://example.com/failed-await'}}));
+  try {
+    const outcome = await awaitJob('260101T1111', 'flj');
+    assert.equal(outcome, 'failed');
+  }
+  finally {
+    await fs.unlink(failedPath);
+  }
+});
+
+test('awaitJob polls until a queued job completes, then returns "completed"', async () => {
+  process.env.AWAIT_JOB_POLL_MS = '20';
+  process.env.AWAIT_JOB_TIMEOUT_MS = '2000';
+  const jobName = '260101T2222-plj';
+  const queuedPath = path.join(jobsPath(), 'queue', `${jobName}.json`);
+  const reportPath = path.join(reportsPath(), `${jobName}.json`);
+  await fs.writeFile(queuedPath, getJSON({target: {what: 'Polled Page', url: 'https://example.com/polled'}}));
+  // Simulate the job completing shortly after the wait begins.
+  setTimeout(async () => {
+    await fs.unlink(queuedPath).catch(() => {});
+    await fs.writeFile(reportPath, getJSON({id: jobName, target: {what: 'Polled Page', url: 'https://example.com/polled'}}));
+  }, 50);
+  try {
+    const outcome = await awaitJob('260101T2222', 'plj');
+    assert.equal(outcome, 'completed');
+  }
+  finally {
+    delete process.env.AWAIT_JOB_POLL_MS;
+    delete process.env.AWAIT_JOB_TIMEOUT_MS;
+    await fs.unlink(queuedPath).catch(() => {});
+    await fs.unlink(reportPath).catch(() => {});
+  }
+});
+
+test('awaitJob returns "timedOut" when a claimed job neither completes nor fails before the deadline', async () => {
+  process.env.AWAIT_JOB_POLL_MS = '10';
+  process.env.AWAIT_JOB_TIMEOUT_MS = '50';
+  const jobName = '260101T3333-toj';
+  const claimedPath = path.join(jobsPath(), 'claimed', `${jobName}.json`);
+  await fs.writeFile(claimedPath, getJSON({target: {what: 'Stuck Page', url: 'https://example.com/stuck'}}));
+  try {
+    const outcome = await awaitJob('260101T3333', 'toj');
+    assert.equal(outcome, 'timedOut');
+  }
+  finally {
+    delete process.env.AWAIT_JOB_POLL_MS;
+    delete process.env.AWAIT_JOB_TIMEOUT_MS;
+    await fs.unlink(claimedPath);
+  }
+});

package/util.ts

@@ -78,9 +78,13 @@ export type TestRequest = {
 // Test requests by URL.
 export type TestRequests = Record<string, TestRequest[]>;
 
-// Test request addition result.
+// Test request addition result. 'reportExists' means a report already exists for a
+// page a newTest request or order named (an outcome), distinct from the 'retest'
+// requestType discriminant elsewhere in this file, which means the caller asked to
+// retest a page that already has a report (a request kind); the two must not be
+// confused with one another.
 export type TestRequestResult
-= 'url' | 'description' | 'retest' | 'duplicate' | 'superseded' | 'nonreport' | 'queueFull' | 'ok';
+= 'url' | 'description' | 'reportExists' | 'duplicate' | 'superseded' | 'nonreport' | 'queueFull' | 'ok';
 
 // Target of a new-test or retest request: a description and URL for a new-test request,
 // or the timeStamp and jobID of the cited report for a retest request.
@@ -1127,7 +1131,7 @@ export const processTestRequest = (
   reason: string,
   target: TestRequestTarget
 ): Promise<ProcessRequestResult> => testRequestsLock(async (): Promise<ProcessRequestResult> => {
-  let requestType: 'test' | 'retest';
+  let requestType: 'newTest' | 'retest';
   let description: string;
   let url: string;
   // Whether the cited report (for a retest) has been superseded by a later one.
@@ -1152,7 +1156,7 @@ export const processTestRequest = (
   }
   // Otherwise, i.e. if the target is a page to test for the first time:
   else {
-    requestType = 'test';
+    requestType = 'newTest';
     ({description, url} = target);
   }
   try {
@@ -1186,11 +1190,11 @@ export const processTestRequest = (
       return {result: 'superseded', description, url};
     }
     // Otherwise, if the request is to test a new page for which a report already exists:
-    if (requestType === 'test') {
+    if (requestType === 'newTest') {
       const reportExtracts = await getReportExtracts();
       if (reportExtracts.some(report => report.description === description && report.url === url)) {
         // Return this.
-        return {result: 'retest', description, url};
+        return {result: 'reportExists', description, url};
       }
     }
     // Otherwise, i.e. if the request is genuinely new, if the queue of requests awaiting
@@ -1215,8 +1219,9 @@ export const processTestRequest = (
     // Alert a manager, including the resulting queue size, so a maintainer who has been
     // away sees at a glance how urgently the queue needs review (approval or rejection)
     // rather than learning this only once it is already full.
+    const requestTypeLabel = requestType === 'newTest' ? 'a new test' : 'a retest';
     await sendAlert(
-      `Kilotest: new ${requestType} request awaits approval`,
+      `Kilotest: request for ${requestTypeLabel} awaits approval`,
       `Page description: ${description}\nURL: ${url}\nReason: ${plainReason}\n` +
       `Requests now awaiting approval: ${getPendingTestRequestCount(testRequests)} of ${describeMax(queueMax)}`
     );
@@ -1228,6 +1233,169 @@ export const processTestRequest = (
     throw new Error('Failed to process test request', {cause: error});
   }
 });
+// Maximum number of jobs allowed in the job queue (db/jobs/queue) at once. This queue is
+// shared by every path that enqueues a job: manual approval of a pending test/retest
+// request (web/enqueue), and any tool (such as orderNewTest) that enqueues directly. The cap
+// therefore protects the queue itself, not any one source of jobs; a value of 0 means no
+// limit. Configurable via JOB_QUEUE_MAX.
+const jobQueueMax = () => getEnvMax('JOB_QUEUE_MAX', 20);
+// Result of orderJob. description and url are absent only when the result is
+// 'nonreport' (a retest order citing a report that does not exist), matching
+// ProcessRequestResult's own discriminated-union shape. There is no pending approval
+// inbox to compare against, so 'duplicate' (an identical pending request) never applies.
+// jobID (the enqueued job's own identifier, timeStamp-jobID) is present only on 'ok'.
+export type OrderJobResult
+= {result: 'nonreport'}
+| {result: 'ok'; description: string; url: string; jobID: string}
+| {result: Exclude<TestRequestResult, 'nonreport' | 'duplicate' | 'ok'>; description: string; url: string};
+// Orders a test or retest as a transaction: validates the target is not already queued,
+// claimed, or (for a new-page order) reported, then enqueues a job directly into
+// db/jobs/queue, bypassing the pending-approval inbox (testRequests.json) that
+// processTestRequest writes to. This is the auto-approval GitHub issue #111 asks for: a
+// lightweight gate (the same claimed/queued dedup check processTestRequest already
+// performs, plus a cap on the queue itself) substitutes for a maintainer's manual
+// review. Runs under testRequestsLock, the same lock processTestRequest uses, so an
+// orderJob call and a processTestRequest call can never race to enqueue duplicate jobs
+// for the same page. The caller's stated reason is recorded on the job (sources.reason),
+// which survives into the eventual report exactly as sources.worker already does: no
+// approval rule consults it yet, but accumulating real callers' stated reasons is
+// intended to inform the design of more sophisticated, reason-aware approval rules in a
+// later iteration.
+export const orderJob = (
+  target: TestRequestTarget, reason: string
+): Promise<OrderJobResult> => testRequestsLock(async (): Promise<OrderJobResult> => {
+  let description: string;
+  let url: string;
+  // Whether the cited report (for a retest order) has been superseded by a later one.
+  let superseded = false;
+  // If the target identifies a report to retest:
+  if ('timeStamp' in target) {
+    const {timeStamp, jobID} = target;
+    // Get the cited report.
+    const extract = await getReportExtract(timeStamp, jobID);
+    // If it does not exist:
+    if ('error' in extract) {
+      // Return this.
+      return {result: 'nonreport'};
+    }
+    ({description, url} = extract);
+    // Get whether it has been superseded by a later report.
+    const reportExtracts = await getReportExtracts();
+    superseded = reportExtracts.some(
+      ex => ex.timeStamp === timeStamp && ex.jobID === jobID && ex.superseded
+    );
+  }
+  // Otherwise, i.e. if the target is a page to test for the first time:
+  else {
+    ({description, url} = target);
+  }
+  try {
+    // Get any property the page shares with a claimed job.
+    const claimedJobProperty = await getApprovedJobProperty(description, url, 'claimed');
+    // Get any property the page shares with a queued job.
+    const queueJobProperty = await getApprovedJobProperty(description, url, 'queue');
+    // If the page shares a property with a claimed or queued job:
+    if (claimedJobProperty || queueJobProperty) {
+      // Return the property.
+      return {
+        result: (claimedJobProperty || queueJobProperty) as 'description' | 'url',
+        description,
+        url
+      };
+    }
+    // Otherwise, if the order is to retest a page that has been superseded:
+    if ('timeStamp' in target && superseded) {
+      // Return this.
+      return {result: 'superseded', description, url};
+    }
+    // Otherwise, if the order is to test a new page for which a report already exists:
+    if (!('timeStamp' in target)) {
+      const reportExtracts = await getReportExtracts();
+      if (reportExtracts.some(report => report.description === description && report.url === url)) {
+        // Return this.
+        return {result: 'reportExists', description, url};
+      }
+    }
+    // Otherwise, if the job queue is already full (a cap of 0 means no limit, so the
+    // queue is never full):
+    const queueMax = jobQueueMax();
+    const {queue: queuedJobNames} = await getJobNames();
+    if (queueMax > 0 && queuedJobNames.length >= queueMax) {
+      // Return this.
+      return {result: 'queueFull', description, url};
+    }
+    // The page is eligible, so build a job from the template.
+    const jobTemplateJSON = await fs.readFile(path.join(import.meta.dirname, 'job.json'), 'utf8');
+    const job = JSON.parse(jobTemplateJSON);
+    const nowStamp = getNowStamp();
+    const jobIDSuffix = getRandomString(3);
+    const jobName = `${nowStamp}-${jobIDSuffix}`;
+    job.id = jobName;
+    job.creationTimeStamp = nowStamp;
+    job.executionTimeStamp = nowStamp;
+    job.target.what = description;
+    job.target.url = url;
+    job.sources.reason = reason;
+    // Save the job in the queue.
+    await fs.writeFile(path.join(jobsPath(), 'queue', `${jobName}.json`), getJSON(job));
+    console.log(`Test ordered for ${description} as job ${jobName}`);
+    // Return success, with the job identifier so the caller can report it.
+    return {result: 'ok', description, url, jobID: jobName};
+    // If an error occurred:
+  } catch(error) {
+    // Throw it.
+    throw new Error('Failed to order test', {cause: error});
+  }
+});
+// Milliseconds between polls in awaitJob, and the maximum total milliseconds awaitJob
+// waits before giving up. Both are read at call time (not cached), via environment
+// variables, so tests can shrink them well below the real ~2-to-4-minute wait a
+// production caller experiences; AWAIT_JOB_TIMEOUT_MS deliberately exceeds the
+// documented "occasionally up to 4 minutes" a caller is told to expect, leaving margin
+// so a job that is genuinely still running is not mistaken for one that never will
+// finish.
+const awaitJobPollMs = () => getEnvMax('AWAIT_JOB_POLL_MS', 2000);
+const awaitJobTimeoutMs = () => getEnvMax('AWAIT_JOB_TIMEOUT_MS', 5 * 60 * 1000);
+// Result of awaitJob.
+export type AwaitJobResult = 'completed' | 'failed' | 'timedOut' | 'notFound';
+// Waits for a job ordered via orderJob (or, in principle, any job in db/jobs/queue or
+// db/jobs/claimed identified the same way) to leave the queue/claimed pipeline, by
+// polling for the outcome Kilotest already records for it: a completed report at
+// timeStamp-jobID.json (see index.ts's worker/report handler, which is the sole writer
+// of that file), or the job's own file having moved to db/jobs/failed (see
+// index.ts's processJobRequest and worker/report handler, which are the only
+// code that reclassifies a job as failed). Returns 'notFound' immediately, without
+// polling, if the identifier names neither a completed report nor a job anywhere in the
+// queue/claimed/failed pipeline, since there is then nothing to wait for. No progress
+// notifications are emitted during the wait; this is a pure bounded poll.
+export const awaitJob = async (timeStamp: string, jobID: string): Promise<AwaitJobResult> => {
+  const jobFileName = `${timeStamp}-${jobID}.json`;
+  const pollMs = awaitJobPollMs();
+  const timeoutMs = awaitJobTimeoutMs();
+  const deadline = Date.now() + timeoutMs;
+  // Returns the job's outcome if it is now determinable, or null if it is still pending.
+  const checkOutcome = async (): Promise<AwaitJobResult | null> => {
+    if (await getReportStats(timeStamp, jobID)) {
+      return 'completed';
+    }
+    const jobNames = await getJobNames();
+    if (jobNames.failed.includes(jobFileName)) {
+      return 'failed';
+    }
+    if (jobNames.queue.includes(jobFileName) || jobNames.claimed.includes(jobFileName)) {
+      return null;
+    }
+    // The identifier names neither a report nor a job anywhere in the pipeline.
+    return 'notFound';
+  };
+  // If the job is not yet determinable, poll until it is or the deadline passes.
+  let outcome = await checkOutcome();
+  while (outcome === null && Date.now() < deadline) {
+    await new Promise(resolve => setTimeout(resolve, pollMs));
+    outcome = await checkOutcome();
+  }
+  return outcome ?? 'timedOut';
+};
 
 // METRICS FUNCTIONS
 

package/web/listReports/index.html

@@ -18,7 +18,7 @@
         __requests__
       </ol>
       <p>__noRequests__</p>
-      <p>Should Kilotest <a href="requestTestForm.html">test a page</a> that is not listed below?</p>
+      <p>Should Kilotest <a href="requestNewTestForm.html">test a page</a> that is not listed below?</p>
       <h2>Queued for testing</h2>
       <ol>
         __queue__

package/web/listReports/listReports.test.ts

@@ -84,7 +84,7 @@ test('listReports includes the page URLs in the report details', async () => {
 test('listReports includes a link to request testing a new page', async () => {
   const result: any = await answer();
   const html = parse(result.answerPage);
-  const testLink = html.querySelector('a[href="requestTestForm.html"]');
+  const testLink = html.querySelector('a[href="requestNewTestForm.html"]');
   assert.ok(testLink);
 });
 

package/web/{requestTest → requestNewTest}/index.ts

@@ -34,7 +34,7 @@ export const answer = async (description: string, url: string, reason: string) =
     };
   }
   // Otherwise, if a report is available about a page with the same description and URL:
-  else if (result === 'retest') {
+  else if (result === 'reportExists') {
     // Report this.
     return {
       status: 'error',

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

@@ -1,6 +1,6 @@
 /*
-  requestTest.test.ts
-  Unit tests for web/requestTest/index.ts, covering the success path of answer.
+  requestNewTest.test.ts
+  Unit tests for web/requestNewTest/index.ts, covering the success path of answer.
 */
 
 // IMPORTS

package/web/{requestTestForm → requestNewTestForm}/index.html

@@ -14,7 +14,7 @@
     <main>
       <h1><a href="/">Kilotest</a>: Test request</h1>
       <p>You may request that a web page be tested by submitting the following form. All answers are required.</p>
-      <form action="/requestTest.html" method="post">
+      <form action="/requestNewTest.html" method="post">
         <p><label>
           Propose a name for the page.<br>
           <input size="50" maxlength="70" name="description" required>

package/web/{requestTestForm/requestTestForm.test.ts → requestNewTestForm/requestNewTestForm.test.ts}

@@ -1,6 +1,6 @@
 /*
-  requestTestForm.test.ts
-  Unit tests for web/requestTestForm/index.ts.
+  requestNewTestForm.test.ts
+  Unit tests for web/requestNewTestForm/index.ts.
 */
 
 // IMPORTS
@@ -12,7 +12,7 @@ import {answer} from './index.ts';
 
 // TESTS
 
-test('requestTestForm returns an ok status with valid HTML', async () => {
+test('requestNewTestForm returns an ok status with valid HTML', async () => {
   const result = await answer();
   assert.equal(result.status, 'ok');
   assert.ok(result.answerPage);
@@ -20,16 +20,16 @@ test('requestTestForm returns an ok status with valid HTML', async () => {
   assert.equal(html.querySelector('title')?.text, 'Test request | Kilotest');
 });
 
-test('requestTestForm includes a form that posts to /requestTest.html', async () => {
+test('requestNewTestForm includes a form that posts to /requestNewTest.html', async () => {
   const result = await answer();
   const html = parse(result.answerPage);
   const form = html.querySelector('form');
   assert.ok(form);
-  assert.equal(form.getAttribute('action'), '/requestTest.html');
+  assert.equal(form.getAttribute('action'), '/requestNewTest.html');
   assert.equal(form.getAttribute('method'), 'post');
 });
 
-test('requestTestForm includes required inputs for description, url, and why', async () => {
+test('requestNewTestForm includes required inputs for description, url, and why', async () => {
   const result = await answer();
   const html = parse(result.answerPage);
   const inputs = html.querySelectorAll('input');