@jrpool/kilotest 46.1.0 → 47.0.1

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

@@ -1,37 +1,39 @@
 /*
-  requestTest.test.js
-  Tests for api/requestTest.js using the fixture corpus, with mocked side effects.
+  requestTest.test.ts
+  Tests for api/requestTest.ts using the fixture corpus.
 */
 
 // IMPORTS
 
-const {test, before, beforeEach, after} = require('node:test');
-const assert = require('node:assert/strict');
-const path = require('node:path');
-const apiUtil = require('./util');
+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;
-let processTestRequestCalls = [];
+const testRequestsPath = path.join(fixtureDBDir, 'jobs', 'testRequests.json');
+let logged: any[] = [];
+const originalLog = console.log;
 
 before(() => {
-  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
-  // @ts-expect-error: Replacing the real function with a mock for testing.
-  apiUtil.processTestRequest = async (testType, what, url, reason) => {
-    processTestRequestCalls.push({testType, what, url, reason});
-  };
+  process.env.DB_DIR = fixtureDBDir;
 });
 
-// Reset the call log before each test, so tests do not depend on execution order.
-beforeEach(() => {
-  processTestRequestCalls = [];
+// 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(' '));
 });
 
-// Require requestTest after the mock is in place, so it captures the mocked processTestRequest.
-const {response} = require('./requestTest');
+import {response} from './requestTest.ts';
 
 after(() => {
+  console.log = originalLog;
   if (savedDBDir !== undefined) {
     process.env.DB_DIR = savedDBDir;
   }
@@ -44,44 +46,47 @@ after(() => {
 
 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'].error);
-  assert.equal(processTestRequestCalls.length, 0);
+  assert.ok((body['response content']['details about your request'] as any).error);
+  assert.ok(!logged.some(line => line.includes('request in the API')));
 });
 
 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'].error);
-  assert.equal(processTestRequestCalls.length, 0);
+  assert.ok((body['response content']['details about your request'] as any).error);
+  assert.ok(!logged.some(line => line.includes('request in the API')));
 });
 
 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'].error);
-  assert.equal(processTestRequestCalls.length, 0);
+  assert.ok((body['response content']['details about your request'] as any).error);
+  assert.ok(!logged.some(line => line.includes('request in the API')));
 });
 
 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'];
+  const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('invalid URL'));
-  assert.equal(processTestRequestCalls.length, 0);
+  assert.ok(!logged.some(line => line.includes('request in the API')));
 });
 
 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'];
+  const details = body['response content']['details about your request'] as any;
   assert.ok(details.error.includes('already been tested'));
-  assert.equal(processTestRequestCalls.length, 0);
+  assert.ok(!logged.some(line => line.includes('request in the API')));
 });
 
 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'];
+  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.equal(processTestRequestCalls.length, 1);
-  assert.equal(processTestRequestCalls[0].testType, 'test');
+  assert.ok(logged.some(line =>
+    line.startsWith('WARNING (Kilotest: new test request in the API)')
+    && line.includes('Brand New Page')
+    && line.includes('https://example.com/brandnew')
+  ));
 });
 
 test('requestTest includes disposition information for a valid request', async () => {

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

@@ -1,42 +1,45 @@
 /*
-  requestTest.js
+  requestTest.ts
   Processes a request to test an untested page and returns an acknowledgement.
 */
 
 // IMPORTS
 
-const {getResponseMetadata, getToolsFacts, processTestRequest, thisHost} = require('./util');
-const {getReportExtracts, isURL} = require('../util');
+import {z} from 'zod';
+import {getResponseMetadata, getThisHost, getToolsFacts, processTestRequest} from './util.ts';
+import {getReportExtracts, isURL} 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.
-exports.response = async args => {
-  const [what = '', url = '', reason = ''] = args;
-  // Initialize the response content.
-  const responseContent = {
-    'details about your request': {},
-    'disposition of your request': null
-  };
-  const whatLength = what.length;
+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 (!whatLength || whatLength > 100) {
-    // Add this to the response content.
-    responseContent['details about your request'] = {
+  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) {
-    // Add this to the response content.
-    responseContent['details about your request'] = {
+    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)) {
-    // Add this to the response content.
-    responseContent['details about your request'] = {
+    requestDetails = {
       error: 'request invalid: you specified an invalid URL for the page'
     };
   }
@@ -46,34 +49,38 @@ exports.response = async args => {
     const reportExtracts = await getReportExtracts();
     // If any report is on a page with the specified description and URL:
     if (
-      reportExtracts.some(extract => extract.what === what && extract.url === url)
+      reportExtracts.some(extract => extract.description === description && extract.url === url)
     ) {
-      // Add this to the response content.
-      responseContent['details about your request'] = {
+      requestDetails = {
         error: 'request invalid: the page has already been tested and its report is available'
       };
     }
     // Otherwise, i.e. if none is on the page:
     else {
       // Process the request.
-      await processTestRequest('test', what, url, reason);
-      // Add details about the request to the response content.
-      responseContent['details about your request'] = {
+      await processTestRequest('test', description, url, reason);
+      // Add details about the request.
+      requestDetails = {
         'date and time received': new Date().toISOString(),
         'page to be tested': {
-          description: what,
+          description,
           URL: url
         },
         'reason why the page should be tested': reason
       };
-      // Add information about the disposition of the request to the response content.
-      responseContent['disposition of your request'] = {
+      // Add information about the disposition of the request.
+      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.`
       };
     }
   }
+  // 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(),
@@ -83,7 +90,7 @@ exports.response = async args => {
       method: 'POST',
       URL: `${thisHost}/api/requestTest`,
       body: {
-        description: what,
+        description,
         URL: url,
         reason
       },

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,13 @@
 /*
-  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, processTestRequest} from './util.ts';
 
 // SETUP
 
@@ -64,8 +63,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,11 +74,32 @@ 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.');
+  const result: any = 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');
   if (savedDBDir !== undefined) {