@jrpool/kilotest 59.1.4 → 60.0.1

package/util.test.ts

@@ -1009,8 +1009,8 @@ test('processTestRequest returns "url" for a page matching a queued job by an eq
 });
 
 test('processTestRequest returns "nonreport" when the cited report does not exist', async () => {
-  // Cite a timeStamp/jobID that does not correspond to any available report.
-  const {result} = await processTestRequest('because', {timeStamp: '999999T9999', jobID: 'xxx'});
+  // Cite a reportID that does not correspond to any available report.
+  const {result} = await processTestRequest('because', {reportID: '999999T9999-xxx'});
   assert.equal(result, 'nonreport');
 });
 
@@ -1259,7 +1259,7 @@ test('getReport returns an error for an invalid report', async () => {
   process.env.DB_DIR = tmpDir;
   try {
     const {getReport} = await import('./util.ts');
-    const result = await getReport('260101T0000', 'bad') as any;
+    const result = await getReport('260101T0000-bad') as any;
     assert.ok(result.error);
     assert.ok(result.error.includes('not usable'));
   }
@@ -1408,7 +1408,7 @@ test('testRequestsLock is a function (the lock returned by createLock)', () => {
 });
 
 test('getReportPath returns the path of a report file', () => {
-  const result = getReportPath('260101T0000', 'mix');
+  const result = getReportPath('260101T0000-mix');
   assert.ok(result.endsWith('260101T0000-mix.json'));
 });
 
@@ -1422,29 +1422,28 @@ test('getReportEndTime returns an invalid date for a report with no completion t
 });
 
 test('getReportStats returns reportSize for a valid report', async () => {
-  const stats = await getReportStats('260101T0000', 'mix');
+  const stats = await getReportStats('260101T0000-mix');
   assert.ok(stats);
   assert.equal(typeof stats.reportSize, 'number');
   assert.ok(stats.reportSize > 0);
 });
 
 test('getReportStats returns null for a nonexistent report', async () => {
-  const stats = await getReportStats('999999T9999', 'xxx');
+  const stats = await getReportStats('999999T9999-xxx');
   assert.equal(stats, null);
 });
 
 
 test('getReportExtract returns an extract for a valid report', async () => {
-  const extract = await getReportExtract('260101T0000', 'mix') as any;
-  assert.equal(extract.timeStamp, '260101T0000');
-  assert.equal(extract.jobID, 'mix');
+  const extract = await getReportExtract('260101T0000-mix') as any;
+  assert.equal(extract.id, '260101T0000-mix');
   assert.equal(extract.description, 'Mixed Outcomes');
   assert.equal(extract.url, 'https://example.com/mixed');
   assert.ok(extract.reportTime);
 });
 
 test('getReportExtract returns an error for a nonexistent report', async () => {
-  const extract = await getReportExtract('999999T9999', 'xxx') as any;
+  const extract = await getReportExtract('999999T9999-xxx') as any;
   assert.ok(extract.error);
 });
 
@@ -1465,7 +1464,7 @@ test('getReportExtract returns an error for an unusable report', async () => {
         jobData: {endTime: '26-01-01T00:00'}
       })
     );
-    const extract = await getReportExtract('260101T0000', 'bad') as any;
+    const extract = await getReportExtract('260101T0000-bad') as any;
     assert.ok(extract.error);
   }
   finally {
@@ -1485,7 +1484,7 @@ test('quarantineReport ignores a missing report', async () => {
   const savedDbDir = process.env.DB_DIR;
   process.env.DB_DIR = path.join(tmpRoot, 'db');
   try {
-    await quarantineReport('999999T9999', 'xxx', 'not usable');
+    await quarantineReport('999999T9999-xxx', 'not usable');
     // Nothing was created or moved.
     assert.deepEqual(await fs.readdir(tmpRoot), []);
   }
@@ -1510,7 +1509,7 @@ test('quarantineReport leaves a recently modified report in place', async () =>
   const savedDbDir = process.env.DB_DIR;
   process.env.DB_DIR = path.join(tmpRoot, 'db');
   try {
-    await quarantineReport('260101T0000', 'bad', 'not usable');
+    await quarantineReport('260101T0000-bad', 'not usable');
     // The fresh file may still be mid-write, so it was not moved.
     await fs.access(filePath);
   }
@@ -1538,7 +1537,7 @@ test('quarantineReport quarantines a report old enough to be quarantined', async
   const savedDbDir = process.env.DB_DIR;
   process.env.DB_DIR = path.join(tmpRoot, 'db');
   try {
-    await quarantineReport('260101T0000', 'bad', 'not usable');
+    await quarantineReport('260101T0000-bad', 'not usable');
     // The file was moved to the unusable-reports directory.
     await fs.access(filePath).then(
       () => {throw new Error('Report should have been quarantined');},
@@ -1573,7 +1572,7 @@ test('quarantineReport leaves the file and logs when the move fails', async () =
   const savedDbDir = process.env.DB_DIR;
   process.env.DB_DIR = path.join(tmpRoot, 'db');
   try {
-    await quarantineReport('260101T0000', 'bad', 'not usable');
+    await quarantineReport('260101T0000-bad', 'not usable');
     // The report stays where it was.
     await fs.access(filePath);
   }
@@ -1602,7 +1601,7 @@ test('getReport quarantines a malformed report file old enough to be quarantined
   process.env.DB_DIR = path.join(tmpRoot, 'db');
   try {
     const {getReport} = await import('./util.ts');
-    const result = await getReport('260101T0000', 'bad') as any;
+    const result = await getReport('260101T0000-bad') as any;
     assert.ok(result.error);
     // The malformed file was quarantined.
     const quarantined = await fs.readdir(path.join(tmpRoot, 'db', 'unusableReports'));
@@ -1622,7 +1621,7 @@ test('getReport quarantines a malformed report file old enough to be quarantined
 test('getReportExtracts returns extracts of all available reports', async () => {
   const extracts = await getReportExtracts();
   assert.ok(extracts.length >= 8);
-  const ids = extracts.map(e => `${e.timeStamp}-${e.jobID}`);
+  const ids = extracts.map(e => e.id);
   assert.ok(ids.includes('260101T0000-mix'));
   assert.ok(ids.includes('260101T0001-ct'));
 });
@@ -1631,7 +1630,7 @@ test('getReportExtracts with onlyLatest returns only the latest report for each
   const latest = await getReportExtracts(true);
   const mixReports = latest.filter(e => e.description === 'Mixed Outcomes');
   assert.equal(mixReports.length, 1);
-  assert.equal(mixReports[0]!.timeStamp, '260202T0000');
+  assert.equal(mixReports[0]!.id, '260202T0000-new');
 });
 
 test('getReportExtracts reflects reports added, modified, and removed after a previous call', async () => {
@@ -1918,14 +1917,14 @@ test('getMetrics backfills every category, and generates a since stamp, from a b
 // 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(
+  const {result, description, url, reportID} = 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`);
+  assert.match(reportID, /^\d{6}T\d{4}-[a-z0-9]{3}$/);
+  const queuedPath = path.join(jobsPath(), 'queue', `${reportID}.json`);
   try {
     const job = JSON.parse(await fs.readFile(queuedPath, 'utf8'));
     assert.equal(job.target.what, 'Ordered Page');
@@ -2010,7 +2009,7 @@ test('orderJob throws when a job file in a category directory is defective', asy
 });
 
 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');
+  const {result} = await orderJob({reportID: '999999T9999-xxx'}, 'because accessibility matters here');
   assert.equal(result, 'nonreport');
 });
 
@@ -2018,19 +2017,19 @@ test('orderJob returns "superseded" when a retest order cites a superseded repor
   // 260101T0000-mix is an earlier report of "Mixed Outcomes" than 260202T0000-new,
   // so it is superseded.
   const {result} = await orderJob(
-    {timeStamp: '260101T0000', jobID: 'mix'}, 'because accessibility matters here'
+    {reportID: '260101T0000-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'
+  const {result, description, url, reportID} = await orderJob(
+    {reportID: '260202T0000-new'}, 'because accessibility matters here'
   ) as any;
   assert.equal(result, 'ok');
   assert.equal(description, 'Mixed Outcomes');
   assert.equal(url, 'https://example.com/mixed');
-  const queuedPath = path.join(jobsPath(), 'queue', `${jobID}.json`);
+  const queuedPath = path.join(jobsPath(), 'queue', `${reportID}.json`);
   try {
     const job = JSON.parse(await fs.readFile(queuedPath, 'utf8'));
     assert.equal(job.target.what, 'Mixed Outcomes');
@@ -2062,12 +2061,12 @@ test('orderJob never returns queueFull when JOB_QUEUE_MAX is 0 (no limit)', asyn
   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(
+    const {result, reportID} = 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`));
+    await fs.unlink(path.join(jobsPath(), 'queue', `${reportID}.json`));
   }
   finally {
     delete process.env.JOB_QUEUE_MAX;
@@ -2076,12 +2075,12 @@ test('orderJob never returns queueFull when JOB_QUEUE_MAX is 0 (no limit)', asyn
 });
 
 test('awaitJob returns "completed" immediately when a report already exists', async () => {
-  const outcome = await awaitJob('260101T0000', 'mix');
+  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');
+  const outcome = await awaitJob('999999T9999-xxx');
   assert.equal(outcome, 'notFound');
 });
 
@@ -2090,7 +2089,7 @@ test('awaitJob returns "failed" when the job has moved to the failed directory',
   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');
+    const outcome = await awaitJob('260101T1111-flj');
     assert.equal(outcome, 'failed');
   }
   finally {
@@ -2111,7 +2110,7 @@ test('awaitJob polls until a queued job completes, then returns "completed"', as
     await fs.writeFile(reportPath, getJSON({id: jobName, target: {what: 'Polled Page', url: 'https://example.com/polled'}}));
   }, 50);
   try {
-    const outcome = await awaitJob('260101T2222', 'plj');
+    const outcome = await awaitJob('260101T2222-plj');
     assert.equal(outcome, 'completed');
   }
   finally {
@@ -2129,7 +2128,7 @@ test('awaitJob returns "timedOut" when a claimed job neither completes nor fails
   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');
+    const outcome = await awaitJob('260101T3333-toj');
     assert.equal(outcome, 'timedOut');
   }
   finally {

package/util.ts

@@ -89,9 +89,9 @@ export type TestRequestResult
 = '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.
+// or the identifier of the cited report for a retest request.
 export type TestRequestTarget
-= {description: string; url: string} | {timeStamp: string; jobID: string};
+= {description: string; url: string} | {reportID: string};
 
 // Result of processTestRequest. description and url are absent only when the result
 // is 'nonreport', i.e. when the target page could not be resolved; this is a
@@ -134,8 +134,7 @@ export type UsableReport = Omit<Report, 'target' | 'catalog' | 'jobData' | 'acts
 
 // An extract of an available report.
 export type ReportExtract = {
-  timeStamp: string;
-  jobID: string;
+  id: string;
   description: string;
   url: string;
   reportTime: string;
@@ -451,6 +450,13 @@ export const isJobID = (string: string): boolean => {
 export const isTimeStamp = (string: string): boolean => {
   return !!getDateString(string);
 };
+// Returns whether a string is a report identifier: the identifier of the job
+// that produced the report, composed of the job's creation time stamp and its
+// random suffix, joined with a hyphen (example: 260503T0432-x9z).
+export const isReportID = (string: string): boolean => {
+  const match = /^(\d{6}T\d{4})-([a-z0-9]{3})$/.exec(string);
+  return !!match && isTimeStamp(match[1]!) && isJobID(match[2]!);
+};
 // Returns whether a string is a URL.
 export const isURL = (string: string): boolean => {
   try {
@@ -672,8 +678,8 @@ export const getTestActInstances = (
   return pairs;
 };
 // Returns the path of an available report file.
-export const getReportPath = (timeStamp: string, jobID: string): string => path
-.join(reportsPath(), `${timeStamp}-${jobID}.json`);
+export const getReportPath = (reportID: string): string => path
+.join(reportsPath(), `${reportID}.json`);
 // Returns whether a report is usable by Kilotest.
 export const isUsableReport = (report: unknown): report is UsableReport => {
   // Cast to any for the property checks inside the guard — this is appropriate
@@ -707,10 +713,9 @@ const quarantineMinAgeMs = () => getEnvMax('REPORT_QUARANTINE_MIN_AGE_MS', 60000
 // that a defective report is quarantined rather than merely hidden from whichever
 // listing encountered it. Never throws: a failure here must not displace the error
 // that getReport is already reporting.
-export const quarantineReport = async (timeStamp: string, jobID: string, defect: string): Promise<void> => {
-  const jobName = `${timeStamp}-${jobID}`;
+export const quarantineReport = async (reportID: string, defect: string): Promise<void> => {
   // Get the modification time of the report file. A missing file needs no move.
-  const stat = await fs.stat(getReportPath(timeStamp, jobID)).catch(() => null);
+  const stat = await fs.stat(getReportPath(reportID)).catch(() => null);
   if (!stat) {
     return;
   }
@@ -721,26 +726,26 @@ export const quarantineReport = async (timeStamp: string, jobID: string, defect:
   try {
     await fs.mkdir(unusableReportsPath(), {recursive: true});
     await fs.rename(
-      getReportPath(timeStamp, jobID), path.join(unusableReportsPath(), `${jobName}.json`)
+      getReportPath(reportID), path.join(unusableReportsPath(), `${reportID}.json`)
     );
   }
   catch (error: unknown) {
     // The report stays excluded regardless, so a failed move is only logged.
-    console.error(`ERROR: Failed to quarantine report ${jobName} (${errorMessage(error)})`);
+    console.error(`ERROR: Failed to quarantine report ${reportID} (${errorMessage(error)})`);
     return;
   }
   // Alert a manager, who can repair the report in place or delete it.
   await sendAlert(
     'Kilotest: unusable report',
-    `Report ${jobName} is ${defect}. It was moved to the unusableReports directory, where a manager can repair or delete it.`
+    `Report ${reportID} is ${defect}. It was moved to the unusableReports directory, where a manager can repair or delete it.`
   );
 };
 // Returns a report, or an error object if it is missing, unreadable, unparsable, or
 // unusable. A report that exists but cannot be read or is unusable is defective, so
 // it is quarantined rather than merely rejected by whichever read encountered it.
-export const getReport = async (timeStamp: string, jobID: string): Promise<UsableReport | {error: string}> => {
+export const getReport = async (reportID: string): Promise<UsableReport | {error: string}> => {
   try {
-    const reportJSON = await fs.readFile(getReportPath(timeStamp, jobID), 'utf8');
+    const reportJSON = await fs.readFile(getReportPath(reportID), 'utf8');
     const report = JSON.parse(reportJSON);
     // If it is usable:
     if (isUsableReport(report)) {
@@ -750,12 +755,12 @@ export const getReport = async (timeStamp: string, jobID: string): Promise<Usabl
   } catch (error: unknown) {
     // The file exists but cannot be read or parsed, or is already missing.
     // quarantineReport ignores a missing file, so no existence check is needed here.
-    await quarantineReport(timeStamp, jobID, 'unreadable or not JSON');
-    return {error: `Report ${timeStamp}-${jobID} is missing, unreadable, or not JSON (${errorMessage(error)})`};
+    await quarantineReport(reportID, 'unreadable or not JSON');
+    return {error: `Report ${reportID} is missing, unreadable, or not JSON (${errorMessage(error)})`};
   }
   // The report was read but is not usable, so quarantine it.
-  await quarantineReport(timeStamp, jobID, 'not usable');
-  return {error: `Report ${timeStamp}-${jobID} is not usable`};
+  await quarantineReport(reportID, 'not usable');
+  return {error: `Report ${reportID} is not usable`};
 };
 // Returns whether a getReport result is an error (rather than a usable report).
 // A type predicate is used instead of `if (report.error)` because UsableReport
@@ -804,10 +809,10 @@ export const annotateReportObject = async (report: UsableReport): Promise<void>
   }
 };
 // Returns the size of a report, or null if the report does not exist.
-export const getReportStats = async (timeStamp: string, jobID: string) => {
+export const getReportStats = async (reportID: string) => {
   let reportStat;
   try {
-    reportStat = await fs.stat(path.join(reportsPath(), `${timeStamp}-${jobID}.json`));
+    reportStat = await fs.stat(path.join(reportsPath(), `${reportID}.json`));
   }
   catch {
     return null;
@@ -825,8 +830,8 @@ export const getReportEndTime = (report: {jobData?: {endTime?: string}}): Date =
 // Returns an extract of an available report, or an error object if the report cannot
 // be used. An extract exists to expose a report in listings, so it shares getReport's
 // usability bar: a report too defective to expose must produce no extract.
-export const getReportExtract = async (timeStamp: string, jobID: string): Promise<ReportExtract | {error: string}> => {
-  const report = await getReport(timeStamp, jobID);
+export const getReportExtract = async (reportID: string): Promise<ReportExtract | {error: string}> => {
+  const report = await getReport(reportID);
   // If the report is not usable:
   if (isReportError(report)) {
     // Return the reason.
@@ -837,8 +842,7 @@ export const getReportExtract = async (timeStamp: string, jobID: string): Promis
   // Return an extract of it. Usability has already guaranteed these properties,
   // including a valid completion time.
   return {
-    timeStamp,
-    jobID,
+    id: reportID,
     description,
     url,
     reportTime: getReportEndTime({jobData}).toISOString()
@@ -884,8 +888,7 @@ export const getReportExtracts = async (onlyLatest: boolean = false): Promise<Re
     }
     // Otherwise, get a new extract of it. The stat precedes the read, so a change between
     // them leaves a stale modification time in the cache and causes a reread next time.
-    const [timeStamp, jobID] = reportFileName.slice(0, -5).split('-') as [string, string];
-    const extract = await getReportExtract(timeStamp, jobID);
+    const extract = await getReportExtract(reportFileName.slice(0, -5));
     // If this succeeded:
     if (!('error' in extract)) {
       // Cache it and add a copy of it to the array.
@@ -950,7 +953,7 @@ const getApprovedJobProperty = async (
   }
 };
 // Processes a new-test or retest request as a transaction and returns the result.
-// For a retest request (target has a timeStamp and jobID), resolves the description
+// For a retest request (target has a reportID), resolves the description
 // and URL of the cited report itself, so a caller never needs its own
 // getReportExtract call. Approvability (whether the request may proceed) and, if so,
 // its addition to testRequests.json are both decided inside the lock, as a single
@@ -995,11 +998,11 @@ export const processTestRequest = (
   // Whether the cited report (for a retest) has been superseded by a later one.
   let superseded = false;
   // If the target identifies a report to retest:
-  if ('timeStamp' in target) {
+  if ('reportID' in target) {
     requestType = 'retest';
-    const {timeStamp, jobID} = target;
+    const {reportID} = target;
     // Get the cited report.
-    const extract = await getReportExtract(timeStamp, jobID);
+    const extract = await getReportExtract(reportID);
     // If it does not exist:
     if ('error' in extract) {
       // Return this.
@@ -1009,7 +1012,7 @@ export const processTestRequest = (
     // 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
+      ex => ex.id === reportID && ex.superseded
     );
   }
   // Otherwise, i.e. if the target is a page to test for the first time:
@@ -1099,10 +1102,11 @@ const jobQueueMax = () => getEnvMax('JOB_QUEUE_MAX', 20);
 // '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'.
+// reportID (the enqueued job's own identifier, and eventually its report's) is
+// present only on 'ok'.
 export type OrderJobResult
 = {result: 'nonreport'}
-| {result: 'ok'; description: string; url: string; jobID: string}
+| {result: 'ok'; description: string; url: string; reportID: 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
@@ -1125,10 +1129,10 @@ export const orderJob = (
   // 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;
+  if ('reportID' in target) {
+    const {reportID} = target;
     // Get the cited report.
-    const extract = await getReportExtract(timeStamp, jobID);
+    const extract = await getReportExtract(reportID);
     // If it does not exist:
     if ('error' in extract) {
       // Return this.
@@ -1138,7 +1142,7 @@ export const orderJob = (
     // 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
+      ex => ex.id === reportID && ex.superseded
     );
   }
   // Otherwise, i.e. if the target is a page to test for the first time:
@@ -1160,13 +1164,13 @@ export const orderJob = (
       };
     }
     // Otherwise, if the order is to retest a page that has been superseded:
-    if ('timeStamp' in target && superseded) {
+    if ('reportID' in target && superseded) {
       // Return this.
       return {result: 'superseded', description, url};
     }
     // Otherwise, if the order is to test a new page and a report already exists about a
     // page with the same description or URL:
-    if (!('timeStamp' in target) && await isReportAvailable(description, url)) {
+    if (!('reportID' in target) && await isReportAvailable(description, url)) {
       // Return this.
       return {result: 'reportExists', description, url};
     }
@@ -1194,7 +1198,7 @@ export const orderJob = (
     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};
+    return {result: 'ok', description, url, reportID: jobName};
     // If an error occurred:
   } catch(error) {
     // Throw it.
@@ -1222,14 +1226,14 @@ export type AwaitJobResult = 'completed' | 'failed' | 'timedOut' | 'notFound';
 // 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`;
+export const awaitJob = async (reportID: string): Promise<AwaitJobResult> => {
+  const jobFileName = `${reportID}.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)) {
+    if (await getReportStats(reportID)) {
       return 'completed';
     }
     const jobNames = await getJobNames();

package/web/hideReportForm/index.ts

@@ -55,12 +55,11 @@ export const answer = async (_: any, search: string, method: string) => {
   const reportExtracts = await getReportExtracts();
   // For each report:
   for (const reportExtract of reportExtracts) {
-    const {jobID, timeStamp, description, reportTime} = reportExtract;
+    const {id, description, reportTime} = reportExtract;
     // Add the report to the array.
     reportSpecs.push({
       description,
-      timeStamp,
-      jobID,
+      id,
       reportTime
     });
   }
@@ -75,12 +74,12 @@ export const answer = async (_: any, search: string, method: string) => {
   const margin = ' '.repeat(12);
   // For each available report:
   reportSpecs.forEach(spec => {
-    const {jobID, timeStamp, description, reportTime} = spec;
+    const {id, description, reportTime} = spec;
     const when = getDateTimeString(new Date(reportTime));
-    const specString = `${description} (job <code>${timeStamp}-${jobID}</code> completed ${when})`;
+    const specString = `${description} (job <code>${id}</code> completed ${when})`;
     // Add a line with a radio button to hide it.
     lines.push(
-      `${margin}<p><input type="radio" name="report" value="${timeStamp}-${jobID}"> ${specString}</p>`
+      `${margin}<p><input type="radio" name="report" value="${id}"> ${specString}</p>`
     );
   });
   const query: Record<string, string> = {

package/web/listDiagnoses/index.ts

@@ -28,14 +28,13 @@ import {issues as issueSpecs} from 'testaro-issues';
 // Adds parameters to a query for the answer page.
 const populateQuery = async (
   issueID: string,
-  timeStamp: string,
-  jobID: string,
+  reportID: string,
   catalogIndex: string,
   pathID: string | null,
   query: Record<string, any>
 ) => {
   // Get the report.
-  const report = await getReport(timeStamp, jobID);
+  const report = await getReport(reportID);
   // If this failed:
   if (isReportError(report)) {
     // Populate the query with the reason.
@@ -113,12 +112,12 @@ const populateQuery = async (
 };
 // Returns a page answering the diagnoses question.
 export const answer = async (pageArgs: string, search: string) => {
-  const [issueID, timeStamp, jobID, catalogIndex] = pageArgs.split('/') as [string, string, string, string];
+  const [issueID, reportID, catalogIndex] = pageArgs.split('/') as [string, string, string];
   const params = new URLSearchParams(search);
   const pathID = params.get('pathID');
   const query: Record<string, any> = {};
   // Create a query to replace the placeholders.
-  await populateQuery(issueID, timeStamp, jobID, catalogIndex, pathID, query);
+  await populateQuery(issueID, reportID, catalogIndex, pathID, query);
   // If this failed:
   if (query.error) {
     // Return why.