@jrpool/kilotest 46.1.2 → 48.0.0

package/api/requestTest.test.ts

@@ -0,0 +1,153 @@
+/*
+  requestTest.test.ts
+  Tests for api/requestTest.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';
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+const testRequestsPath = path.join(fixtureDBDir, 'jobs', 'testRequests.json');
+let logged: any[] = [];
+const originalLog = console.log;
+
+before(() => {
+  process.env.DB_DIR = fixtureDBDir;
+});
+
+// Reset the test-requests file and capture console.log, so the alert that
+// processTestRequest emits can be observed and tests are order-independent.
+beforeEach(async () => {
+  await fs.writeFile(testRequestsPath, '{}\n');
+  logged = [];
+  console.log = (...args) => logged.push(args.join(' '));
+});
+
+import {response} from './requestTest.ts';
+
+after(() => {
+  console.log = originalLog;
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('requestTest 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')));
+});
+
+test('requestTest 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')));
+});
+
+test('requestTest 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')));
+});
+
+test('requestTest 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')));
+});
+
+test('requestTest 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.
+  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')));
+});
+
+test('requestTest 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'}
+  }));
+  try {
+    const body = await response(['Claimed Test Page', 'https://example.com/other-url', '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('a request to test a page with the same description is already approved.')
+    );
+  }
+  finally {
+    await fs.unlink(claimedPath);
+  }
+});
+
+test('requestTest 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'}
+  }));
+  try {
+    const body = await response(['A Different Page', 'https://example.com/queued-url', '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('a request to test a page with the same URL is already approved.')
+    );
+  }
+  finally {
+    await fs.unlink(queuedPath);
+  }
+});
+
+test('requestTest 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;
+  assert.equal(details.error, undefined);
+  const disposition = body['response content']['disposition of your request'] as any;
+  assert.ok(disposition['what happens next'].includes('an identical request is already awaiting approval.'));
+});
+
+test('requestTest 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.includes('Brand New Page')
+    && line.includes('https://example.com/brandnew')
+  ));
+});
+
+test('requestTest 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']);
+});

package/api/requestTest.ts

@@ -0,0 +1,123 @@
+/*
+  requestTest.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 {isURL, processTestRequest} from '../util.ts';
+import {requestTestResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof requestTestResponseSchema>['response content'];
+
+// FUNCTIONS
+
+// Returns the response body.
+export const response = async (args: string[]) => {
+  const [description = '', url = '', reason = ''] = args;
+  const thisHost = getThisHost();
+  // Initialize the response-content properties.
+  let requestDetails: ResponseContent['details about your request'];
+  let requestDisposition: ResponseContent['disposition of your request'] = null;
+  const descriptionLength = description.length;
+  // If the description is empty or too long:
+  if (!descriptionLength || descriptionLength > 100) {
+    requestDetails = {
+      error: 'request invalid: your description of the page is not between 1 and 100 characters long'
+    };
+  }
+  // Otherwise, i.e. if the URL is too short or too long::
+  else if (url.length < 12 || url.length > 300) {
+    requestDetails = {
+      error: 'request invalid: you specified a URL for the page that is not between 12 and 300 characters long'
+    };
+  }
+  // Otherwise, i.e. if the URL is invalid:
+  else if (!isURL(url)) {
+    requestDetails = {
+      error: 'request invalid: you specified an invalid URL for the page'
+    };
+  }
+  // Otherwise, i.e. if the description and URL are valid:
+  else {
+    // Process the request.
+    const {result: requestResult} = await processTestRequest(reason, {description, url});
+    // Add details about the request.
+    requestDetails = {
+      'date and time received': new Date().toISOString(),
+      'page to be tested': {
+        description,
+        URL: url
+      },
+      '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 {
+        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.'
+      }
+    }
+  }
+  // Create the response content.
+  const responseContent: ResponseContent = {
+    'details about your request': requestDetails,
+    'disposition of your request': requestDisposition
+  };
+  // Create a response body.
+  const body = {
+    'tool collection': getToolsFacts(),
+    'tool name': 'requestTest',
+    '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`,
+      body: {
+        description,
+        URL: url,
+        reason
+      },
+      'closest ancestor request': {
+        'tool name': 'listReports',
+        description: 'Provide basics about all available reports.',
+        method: 'GET',
+        URL: `${thisHost}/api/listReports`
+      }
+    },
+    'URLs of similar requests for web users': {
+      'this request': `${thisHost}/requestTestForm.html`,
+      'closest ancestor request': `${thisHost}/listReports.html`
+    },
+    'response metadata': getResponseMetadata(),
+    'response content': responseContent
+  };
+  // Return it.
+  return body;
+};

package/api/{routes.test.js → routes.test.ts}

@@ -1,13 +1,13 @@
 /*
-  routes.test.js
-  Tests for api/routes.js, verifying the structure and completeness of the OpenAPI route metadata.
+  routes.test.ts
+  Tests for api/routes.ts, verifying the structure and completeness of the OpenAPI route metadata.
 */
 
 // IMPORTS
 
-const {test} = require('node:test');
-const assert = require('node:assert/strict');
-const routes = require('./routes');
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {routes} from './routes.ts';
 
 // TESTS
 

package/api/{routes.js → routes.ts}

@@ -1,12 +1,12 @@
 /*
-  routes.js
-  Route metadata for OpenAPI generation. Pairs each Kilotest API operation with its HTTP method, path template, and the request/response schemas from schemas.js. This table supplies the facts that schemas.js cannot express on its own (method, path, path-vs-body placement), mirroring the manual dispatch in index.js and the // GET/POST comments in schemas.js.
+  routes.ts
+  Route metadata for OpenAPI generation. Pairs each Kilotest API operation with its HTTP method, path template, and the request/response schemas from schemas.ts. This table supplies the facts that schemas.ts cannot express on its own (method, path, path-vs-body placement), mirroring the manual dispatch in index.ts and the // GET/POST comments in schemas.ts.
 */
 
 // IMPORTS
 
-const {z} = require('zod');
-const {
+import {z} from 'zod';
+import {
   listIssuesSchema,
   listViolatorsSchema,
   listDiagnosesSchema,
@@ -22,11 +22,11 @@ const {
   requestTestResponseSchema,
   requestRetestResponseSchema,
   requestFeatureResponseSchema
-} = require('./schemas');
+} from './schemas.ts';
 
 // ROUTES
 
-module.exports = [
+export const routes = [
   {
     operationId: 'listReports',
     method: 'get',

package/api/{schemas.js → schemas.ts}

@@ -1,29 +1,34 @@
 /*
-  schemas.js
-  Zod input and response schemas shared by mcp.js (MCP tool inputSchema/outputSchema), api/routes.js, and the openapi.yaml generation script (scripts/generate-openapi.js). Descriptions and component ids (.meta({id})) in this file are the single source of truth for parameter documentation and OpenAPI component naming and reuse.
+  schemas.ts
+  Zod input and response schemas shared by mcp.ts (MCP tool inputSchema/outputSchema), api/routes.ts, and the openapi.yaml generation script (scripts/generate-openapi.ts). Descriptions and component ids (.meta({id})) in this file are the single source of truth for parameter documentation and OpenAPI component naming and reuse.
 */
 
 // IMPORTS
 
-const {z} = require('zod');
+import {z} from 'zod';
+
+// TYPES
+
+// A Zod schema of any shape, as accepted by the schema-composing helpers below.
+type ZodTypeAny = import('zod').ZodTypeAny;
 
 // REQUEST SCHEMAS
 
 // listIssues: GET /api/listIssues/{timeStamp}/{jobID}
-exports.listIssuesSchema = {
+export const listIssuesSchema = {
   timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
   jobID: z.string().describe('Job identifier of the report (example: x9z)')
 };
 
 // listViolators: GET /api/listViolators/{issueID}/{timeStamp}/{jobID}
-exports.listViolatorsSchema = {
+export const listViolatorsSchema = {
   issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
   timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
   jobID: z.string().describe('Job identifier of the report (example: x9z)')
 };
 
 // listDiagnoses: GET /api/listDiagnoses/{catalogIndex}/{issueID}/{timeStamp}/{jobID}
-exports.listDiagnosesSchema = {
+export const listDiagnosesSchema = {
   catalogIndex: z.string().describe('Identifier of the issue-exhibiting element in the catalog of elements on the page (example: 372)'),
   issueID: z.string().describe('Issue identifier (example: contrastPoor)'),
   timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
@@ -31,31 +36,31 @@ exports.listDiagnosesSchema = {
 };
 
 // getReport: GET /api/getReport/{timeStamp}/{jobID}
-exports.getReportSchema = {
+export const getReportSchema = {
   timeStamp: z.string().describe('Timestamp of the report in YYMMDDTHHmm format (example: 260503T0432)'),
   jobID: z.string().describe('Job identifier of the report (example: x9z)')
 };
 
 // requestTest: POST /api/requestTest
-exports.requestTestSchema = {
+export const requestTestSchema = {
   description: z.string().describe('10- to 100-character description of the page conforming to the naming convention used in the listReports output'),
   URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
 
 // requestRetest: POST /api/requestRetest/{timeStamp}/{jobID}
-exports.requestRetestSchema = {
+export const requestRetestSchema = {
   timeStamp: z.string().describe('Timestamp of the latest report about the page in YYMMDDTHHmm format (example: 260503T0432)'),
   jobID: z.string().describe('Job identifier of the latest report about the page (example: x9z)'),
   reason: z.string().describe('20- to 100-character reason why the page should be retested')
 };
 
 // requestFeature: POST /api/requestFeature
-exports.requestFeatureSchema = {
+export const requestFeatureSchema = {
   feature: z.string().describe('description of requested feature improvement or new feature')
 };
 
-// listReports takes no input; omitted (mcp.js already uses inputSchema: {}).
+// listReports takes no input; omitted (mcp.ts already uses inputSchema: {}).
 
 // RESPONSE SCHEMAS
 
@@ -97,7 +102,7 @@ const requestReferenceSchema = z.object({
 }).meta({id: 'RequestReference'});
 
 // GET endpoints have no 'body'; POST endpoints get a request-specific body schema.
-const thisRequestSchema = (method, bodySchema) => z.object({
+const thisRequestSchema = (method: string, bodySchema?: ZodTypeAny) => z.object({
   description: z.string(),
   method: z.literal(method),
   URL: z.string(),
@@ -105,11 +110,11 @@ const thisRequestSchema = (method, bodySchema) => z.object({
   'closest ancestor request': requestReferenceSchema.nullable()
 });
 
-const envelope = (
-  method,
-  responseContentSchema,
-  bodySchema,
-  /** @type {z.ZodType} */ similarWebSchema = similarWebRequestsSchema
+const envelope = <T extends ZodTypeAny>(
+  method: string,
+  responseContentSchema: T,
+  bodySchema?: ZodTypeAny,
+  similarWebSchema: ZodTypeAny = similarWebRequestsSchema
 ) => z.object({
   'tool collection': toolsFactsSchema,
   'tool name': z.string(),
@@ -133,7 +138,7 @@ const responseMetadataSchema = z.object({
 const reportBasicsSchema = z.object({
   identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
   'completion date and time': z.string(),
-  'days since the report was completed': z.number(),
+  'days since the report was completed': z.number().nullable(),
   'tested web page': z.object({description: z.string(), URL: z.string()}),
   'whether a later report about the same page exists': z.boolean()
 }).meta({id: 'ReportBasics'});
@@ -161,7 +166,7 @@ const issueBasicsOrErrorSchema = z.union([
   z.object({error: z.string()})
 ]).meta({id: 'IssueBasicsOrError'});
 
-exports.listReportsResponseSchema = envelope('GET', z.object({
+export const listReportsResponseSchema = envelope('GET', z.object({
   'basics about all available reports': z.array(reportBasicsSchema.extend({
     'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
     'web users can get details about the report at': z.string()
@@ -175,7 +180,7 @@ exports.listReportsResponseSchema = envelope('GET', z.object({
   'how a web user can request that the page be tested': z.object({URL: z.string()})
 }));
 
-exports.listIssuesResponseSchema = envelope('GET', z.object({
+export const listIssuesResponseSchema = envelope('GET', z.object({
   'basics about the report': reportBasicsOrErrorSchema,
   'details about the report': z.object({
     'job definition': z.object({
@@ -215,20 +220,20 @@ exports.listIssuesResponseSchema = envelope('GET', z.object({
   }).nullable(),
   'how a web user can get the full report in JSON': z.object({URL: z.string()}).nullable(),
   'basics about all issues reported in the report': z.array(issueBasicsSchema.extend({
-    'rule engines with any violations belonging to the issue': z.array(z.string()),
+    'rule engines with any violations belonging to the issue': z.array(z.string().nullable()),
     'how to get details about the issue': z.object({method: z.literal('GET'), URL: z.string()}),
     'web users can get details about the issue at': z.string()
-  }))
+  })).nullable()
 }));
 
-exports.listViolatorsResponseSchema = envelope('GET', z.object({
+export const listViolatorsResponseSchema = envelope('GET', z.object({
   'basics about the report': reportBasicsOrErrorSchema,
   'basics about the issue': issueBasicsOrErrorSchema,
   'details about the issue': z.object({
     'rule engines reporting violations belonging to the issue': z.array(ruleEngineFactsSchema)
   }).nullable(),
-  'basics about all elements reported as exhibiting the issue': z.array(z.object({
-    identifier: z.string(),
+  'basics about all elements exhibiting the issue': z.array(z.object({
+    identifier: z.union([z.string(), z.number()]).describe('Catalog index of the element in the report; a string or number, copied verbatim.'),
     'tag name': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
     'inner text': z.unknown().describe('Copied from the report catalog entry; type not guaranteed.'),
     'count of rule engines reporting that the element exhibited the issue': z.number(),
@@ -237,7 +242,7 @@ exports.listViolatorsResponseSchema = envelope('GET', z.object({
   })).nullable()
 }));
 
-exports.listDiagnosesResponseSchema = envelope('GET', z.object({
+export const listDiagnosesResponseSchema = envelope('GET', z.object({
   'basics about the report': reportBasicsOrErrorSchema,
   'basics about the issue': issueBasicsOrErrorSchema,
   'basics about the element': z.object({
@@ -255,41 +260,55 @@ exports.listDiagnosesResponseSchema = envelope('GET', z.object({
     'description of the violation': z.unknown().describe('Copied from the report instance (what); type not guaranteed.'),
     'severity of the violation on a 0-to-3 scale': z.unknown().describe('Copied from the report instance (ordinalSeverity); type not guaranteed.'),
     'count of violations of the rule by the element': z.number()
-  })).or(z.object({error: z.string()}))
+  })).or(z.object({error: z.string()})).nullable()
 }));
 
-exports.getReportResponseSchema = envelope('GET', z.object({
+export const getReportResponseSchema = envelope('GET', z.object({
   'size of the report in bytes': z.union([z.number(), z.string()]),
   'full report': z.unknown().describe('The full raw Testaro/Testilo report JSON, copied verbatim, or an error object if it could not be retrieved.')
 }));
 
-exports.requestTestResponseSchema = envelope(
+export const requestTestResponseSchema = envelope(
   'POST',
-  z.object({'details about your request': z.union([
-    z.object({error: z.string()}),
-    z.object({
-      'date and time received': z.string(),
-      'page to be tested': z.object({description: z.string(), URL: z.string()}),
-      'reason why the page should be tested': z.string()
-    })
-  ])}),
-  z.object(exports.requestTestSchema)
+  z.object({
+    'details about your request': z.union([
+      z.object({error: z.string()}),
+      z.object({
+        'date and time received': z.string(),
+        'page to be tested': z.object({description: z.string(), URL: z.string()}),
+        'reason why the page should be tested': z.string()
+      })
+    ]),
+    'disposition of your request': z.object({
+      'what happens next': z.string(),
+      'how you can check for completion': z.string(),
+      'how a web user can check for completion': z.string()
+    }).nullable()
+  }),
+  z.object(requestTestSchema)
 );
 
-exports.requestRetestResponseSchema = envelope(
+export const requestRetestResponseSchema = envelope(
   'POST',
-  z.object({'details about your request': z.union([
-    z.object({error: z.string()}),
-    z.object({
-      'date and time received': z.string(),
-      'page to be retested': z.object({description: z.string(), URL: z.string()}),
-      'reason why the page should be retested': z.string()
-    })
-  ])}),
-  z.object({reason: exports.requestRetestSchema.reason})
+  z.object({
+    'details about your request': z.union([
+      z.object({error: z.string()}),
+      z.object({
+        'date and time received': z.string(),
+        'page to be retested': z.object({description: z.string(), URL: z.string()}),
+        'reason why the page should be retested': z.string()
+      })
+    ]),
+    'disposition of your request': z.object({
+      'what happens next': z.string(),
+      'how you can check for completion': z.string(),
+      'how a web user can check for completion': z.string()
+    }).nullable()
+  }),
+  z.object({reason: requestRetestSchema.reason})
 );
 
-exports.requestFeatureResponseSchema = envelope(
+export const requestFeatureResponseSchema = envelope(
   'POST',
   z.object({'details about your request': z.union([
     z.object({error: z.string()}),
@@ -298,6 +317,6 @@ exports.requestFeatureResponseSchema = envelope(
       disposition: z.string()
     })
   ])}),
-  z.object(exports.requestFeatureSchema),
+  z.object(requestFeatureSchema),
   z.null()
 );

package/api/{util.test.js → util.test.ts}

@@ -1,14 +1,14 @@
 /*
-  util.test.js
-  Tests for api/util.js.
+  util.test.ts
+  Tests for api/util.ts.
 */
 
 // IMPORTS
 
-const {test} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const {getReportBasics, getResponseMetadata, getRuleEngineFacts, getRuleEnginesFacts, getIssueSpec, getToolsFacts, processTestRequest} = require('./util');
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {getReportBasics, getResponseMetadata, getRuleEngineFacts, getRuleEnginesFacts, getIssueSpec, getToolsFacts} from './util.ts';
+import {processTestRequest} from '../util.ts';
 
 // SETUP
 
@@ -64,8 +64,8 @@ test('getIssueSpec returns null for the ignorable issue ID', () => {
 });
 
 test('getReportBasics returns an error for a nonexistent report', async () => {
-  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
-  const basics = await getReportBasics('999999T9999', 'xyz');
+  process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
+  const basics: any = await getReportBasics('999999T9999', 'xyz');
   assert.ok(basics.error);
   if (savedDBDir !== undefined) {
     process.env.DB_DIR = savedDBDir;
@@ -75,13 +75,34 @@ test('getReportBasics returns an error for a nonexistent report', async () => {
   }
 });
 
-test('processTestRequest returns an error for a duplicate recommendation', async () => {
-  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+test('getReportBasics returns an error for a report whose extract cannot be read', async () => {
+  process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
+  const fs = await import('node:fs/promises');
+  const path = await import('node:path');
+  const reportPath = path.join(process.env.DB_DIR, 'reports', '888888T8888-bad.json');
+  await fs.writeFile(reportPath, '{"malformed": true}\n');
+  try {
+    const basics: any = await getReportBasics('888888T8888', 'bad');
+    assert.ok(basics.error);
+  }
+  finally {
+    await fs.unlink(reportPath);
+    if (savedDBDir !== undefined) {
+      process.env.DB_DIR = savedDBDir;
+    }
+    else {
+      delete process.env.DB_DIR;
+    }
+  }
+});
+
+test('processTestRequest returns an error for a duplicate request', async () => {
+  process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
   // Submit the same request twice; the second should be a duplicate.
-  await processTestRequest('test', 'Dup Page', 'https://example.com/dup', 'A reason that is long enough.');
-  const result = await processTestRequest('test', 'Dup Page', 'https://example.com/dup', 'A reason that is long enough.');
-  assert.equal(result.status, 'error');
-  assert.equal(result.message, 'Duplicate request');
+  const target = {description: 'Dup Page', url: 'https://example.com/dup'};
+  await processTestRequest('A reason that is long enough.', target);
+  const {result} = await processTestRequest('A reason that is long enough.', target);
+  assert.equal(result, 'duplicate');
   if (savedDBDir !== undefined) {
     process.env.DB_DIR = savedDBDir;
   }