@jrpool/kilotest 46.0.8 → 46.0.14

package/.devin/config.local.json

@@ -6,7 +6,10 @@
       "Exec(cat)",
       "Exec(ls)",
       "Exec(find)",
-      "Exec(git show)"
+      "Exec(git show)",
+      "Exec(git commit)",
+      "Exec(git check-ignore)",
+      "Exec(git remote)"
     ]
   }
 }

package/.github/workflows/{smoke-test.yml → ci.yml}

@@ -1,11 +1,11 @@
-name: Smoke Test
+name: CI
 
 on:
   pull_request:
     branches: [main]
 
 jobs:
-  smoke:
+  ci:
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -22,5 +22,11 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Run lint
+        run: npm run lint
+
+      - name: Run tests with coverage
+        run: npm test
+
       - name: Run smoke test against deployed server
         run: node smokeTest.js

package/README.md

@@ -1,10 +1,15 @@
 # Kilotest
 
+[![npm version](https://img.shields.io/npm/v/@jrpool/kilotest?label=npm)](https://www.npmjs.com/package/@jrpool/kilotest)
+[![license](https://img.shields.io/github/license/jrpool/kilotest?label=license)](LICENSE)
+[![MCP Registry](https://img.shields.io/badge/MCP_Registry-active-success)](https://registry.modelcontextprotocol.io/v0/servers?search=kilotest)
+[![GitHub stars](https://img.shields.io/github/stars/jrpool/kilotest?label=stars)](https://github.com/jrpool/kilotest/stargazers)
+
 An ensemble testing and reporting service for front-end web quality
 
 ## Features
 
-This application uses an ensemble of 10 rule engines to test public web pages for front-end quality (i.e. accessibility, usability, and standards conformity).
+This application uses an ensemble of 12 rule engines to test public web pages for front-end quality (i.e. accessibility, usability, and standards conformity).
 
 The testing paradigm employed by Kilotest is discussed in these papers:
 
@@ -24,7 +29,7 @@ An active production instance of Kilotest may require multiple testing agents to
 
 In the steps below, hosts `T` and `K` may be the same host or two different hosts. Host `T` can be a Debian stable, Ubuntu LTS, Windows, or macOS host. Host `K` can be any server host that can run the latest LTS version of Node.js. If hosts `T` and `K` differ, then they must be open to `https` traffic and host `K` must permit `https` requests from host `T`.
 
-1. Clone the [Testaro project](https://github.com/jrpool/testaro) into a new directory on host `T`.
+1. Clone the [Testaro project](https://github.com/YRA-Tech/testaro) into a new directory on host `T`.
 1. In that directory, install the Testaro dependencies: `npm install`.
 1. Update the Testaro dependencies and rebuild: `npm run deps`.
 1. Clone the Kilotest repository into a new directory on host `K`.
@@ -43,20 +48,21 @@ Contributions are welcome! You can use GitHub issues to initiate discussions and
 
 ## Making Kilotest a service
 
-See the `SERVICE.md` file for instructions on how to make Kilotest a service.
+See the [`SERVICE.md`](docs/SERVICE.md) file for instructions on how to make Kilotest a service.
 
 ## Using Kilotest as an AI tool
 
 Kilotest is not only a web application but also an API and an MCP server. AI platforms and models can use Kilotest via those interfaces.
 
-The URL for models using the MCP server is `http://kilotest.com/mcp`. The MCP server is listed at these services:
+The URL for models using the MCP server is `https://kilotest.com/mcp`. The MCP server is listed at these services:
 
 - [Smithery](https://smithery.ai/servers/pool/kilotest)
 - [Glama](https://glama.ai/mcp/connectors/com.kilotest/kilotest)
 
 There is additional documentation at:
 
-- [AI-TOOLS.md](AI-TOOLS.md)
-- [llms.txt](llms.txt)
-- [llms-full.txt](llms-full.txt)
-- [QAI](https://kilotest.com/qai)
+- [QAI](https://kilotest.com/qai): a tutorial for allowing AI assistants to use Kilotest
+- [AI-TOOLS.md](docs/AI-TOOLS.md): how Kilotest implements the MCP protocol
+- [llms.txt](llms.txt): basic documentation for LLMs
+- [llms-full.txt](llms-full.txt): comprehensive documentation for LLMs
+- [lhm.plugin.json](lhm.plugin.json): documentation for registration with the LobeHub MCP Market

package/alerts.test.js

@@ -0,0 +1,137 @@
+/*
+  alerts.test.js
+  Tests for alerts.js, covering the success, failure, error, timeout, and unconfigured paths.
+*/
+
+// IMPORTS
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const https = require('node:https');
+const {EventEmitter} = require('node:events');
+
+// SETUP AND TEARDOWN
+
+const originalRequest = https.request;
+const savedEnv = {};
+
+before(() => {
+  for (const key of ['MANAGER_EMAIL', 'ALERT_API_HOST', 'ALERT_API_PATH', 'ALERT_API_KEY', 'ALERT_FROM']) {
+    savedEnv[key] = process.env[key];
+  }
+});
+
+after(() => {
+  https.request = originalRequest;
+  for (const key of Object.keys(savedEnv)) {
+    if (savedEnv[key] !== undefined) {
+      process.env[key] = savedEnv[key];
+    }
+    else {
+      delete process.env[key];
+    }
+  }
+  delete require.cache[require.resolve('./alerts')];
+  require('./alerts');
+});
+
+// HELPER
+
+// Replaces https.request with a function that returns a fake request and invokes the callback with a fake response. The mockHandler is called on next tick so that event listeners are attached first.
+const mockRequest = mockHandler => {
+  https.request = (options, callback) => {
+    const req = new EventEmitter();
+    req.write = () => {};
+    req.end = () => {};
+    req.destroy = () => {
+      req.emit('error', new Error('Socket destroyed'));
+    };
+    req.setTimeout = (ms, fn) => {
+      process.nextTick(fn);
+    };
+    const res = new EventEmitter();
+    res.statusCode = 200;
+    process.nextTick(() => mockHandler(req, res, callback));
+    return req;
+  };
+};
+
+// Sets the alert configuration env vars so that sendAlert enters the configured path.
+const setAlertConfig = () => {
+  process.env.MANAGER_EMAIL = 'manager@example.com';
+  process.env.ALERT_API_HOST = 'alert.example.com';
+  process.env.ALERT_API_PATH = '/send';
+  process.env.ALERT_API_KEY = 'test-key';
+  process.env.ALERT_FROM = 'kilotest@example.com';
+};
+
+// Clears the alert configuration env vars so that sendAlert enters the unconfigured path.
+const clearAlertConfig = () => {
+  for (const key of ['MANAGER_EMAIL', 'ALERT_API_HOST', 'ALERT_API_PATH', 'ALERT_API_KEY', 'ALERT_FROM']) {
+    delete process.env[key];
+  }
+};
+
+// Loads alerts.js fresh so it picks up the current env vars and https.request.
+const loadAlerts = () => {
+  delete require.cache[require.resolve('./alerts')];
+  return require('./alerts');
+};
+
+// TESTS
+
+test('sendAlert resolves without sending when configuration is incomplete', async () => {
+  clearAlertConfig();
+  const {sendAlert} = loadAlerts();
+  await sendAlert('Test', 'Body');
+  assert.ok(true);
+});
+
+test('sendAlert logs success when the API responds with a 2xx status', async () => {
+  setAlertConfig();
+  mockRequest((req, res, callback) => {
+    res.statusCode = 200;
+    callback(res);
+    res.emit('end');
+  });
+  const {sendAlert} = loadAlerts();
+  await sendAlert('Test Success', 'Body');
+  https.request = originalRequest;
+  assert.ok(true);
+});
+
+test('sendAlert logs an error when the API responds with a non-2xx status', async () => {
+  setAlertConfig();
+  mockRequest((req, res, callback) => {
+    res.statusCode = 500;
+    callback(res);
+    res.emit('data', 'Server error');
+    res.emit('end');
+  });
+  const {sendAlert} = loadAlerts();
+  await sendAlert('Test Failure', 'Body');
+  https.request = originalRequest;
+  assert.ok(true);
+});
+
+test('sendAlert logs an error when the request errors', async () => {
+  setAlertConfig();
+  mockRequest((req) => {
+    req.emit('error', new Error('Connection refused'));
+  });
+  const {sendAlert} = loadAlerts();
+  await sendAlert('Test Error', 'Body');
+  https.request = originalRequest;
+  assert.ok(true);
+});
+
+test('sendAlert logs an error when the request times out', async () => {
+  setAlertConfig();
+  mockRequest(() => {
+    // Do nothing; the setTimeout mock will fire and call req.destroy().
+  });
+  const {sendAlert} = loadAlerts();
+  await sendAlert('Test Timeout', 'Body');
+  https.request = originalRequest;
+  assert.ok(true);
+});

package/api/listDiagnoses.test.js

@@ -86,3 +86,47 @@ test('listDiagnoses returns an error for a nonexistent report', async () => {
   const basics = body['response content']['basics about the report'];
   assert.ok(basics.error);
 });
+
+test('listDiagnoses returns guideline layer for an issue with a short WCAG code', async () => {
+  const body = await response(['0', 'duplicateID', '260101T0009', 'brd']);
+  const issueBasics = body['response content']['basics about the issue'];
+  assert.equal(issueBasics['related WCAG standard'].layer, 'guideline');
+  assert.equal(issueBasics['related WCAG standard'].identifier, '4.1');
+});
+
+test('listDiagnoses returns null tag name and inner text for a catalog item missing them', async () => {
+  const body = await response(['1', 'duplicateID', '260101T0009', 'brd']);
+  const elementBasics = body['response content']['basics about the element'];
+  assert.equal(elementBasics['tag name'], null);
+  assert.equal(elementBasics['inner text'], null);
+});
+
+test('listDiagnoses returns null rule ID when ruleID equals what', async () => {
+  const body = await response(['0', 'duplicateID', '260101T0009', 'brd']);
+  const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'];
+  const axeDiagnosis = diagnoses.find(d => d['description of the violation'] === 'r99');
+  assert.ok(axeDiagnosis);
+  assert.equal(axeDiagnosis['identifier of the violated rule'], null);
+});
+
+test('listDiagnoses defaults count to 1 when count is missing', async () => {
+  const body = await response(['1', 'duplicateID', '260101T0009', 'brd']);
+  const diagnoses = body['response content']['diagnoses of how the element exhibited the issue'];
+  const ibmDiagnosis = diagnoses.find(d => d['description of the violation'] === 'Element has no role');
+  assert.ok(ibmDiagnosis);
+  assert.equal(ibmDiagnosis['count of violations of the rule by the element'], 1);
+});
+
+test('listDiagnoses returns null for missing start tag, XPath, and bounding box', async () => {
+  const body = await response(['2', 'duplicateID', '260101T0009', 'brd']);
+  const elementDetails = body['response content']['details about the element'];
+  assert.equal(elementDetails['start tag'], null);
+  assert.equal(elementDetails['XPath'], null);
+  assert.equal(elementDetails['x, y, width, and height of bounding box'], null);
+});
+
+test('listDiagnoses returns issue error for a falsy issue ID', async () => {
+  const body = await response(['0', '', '260101T0009', 'brd']);
+  const issueBasics = body['response content']['basics about the issue'];
+  assert.ok(issueBasics.error);
+});

package/api/listIssues.js

@@ -111,7 +111,7 @@ exports.response = async args => {
         'name': getRuleEngineFacts(ruleEngineID).name,
         'reason for failure': reason
       }));
-      const sortedPreventionFacts = objectSort(preventionFacts ?? [], 'name', 'alpha');
+      const sortedPreventionFacts = objectSort(preventionFacts, 'name', 'alpha');
       // Initialize the counts of issues by weight.
       const weightCounts = [0, 0, 0, 0];
       // For each issue:

package/api/listIssues.test.js

@@ -96,3 +96,13 @@ test('listIssues returns an error for a nonexistent report', async () => {
   const basics = body['response content']['basics about the report'];
   assert.ok(basics.error);
 });
+
+test('listIssues handles instances with missing issueID and null instances without error', async () => {
+  const body = await response(['260101T0009', 'brd']);
+  const issues = body['response content']['basics about all issues reported in the report'];
+  // The brd fixture has one instance with duplicateID (a valid issue) and one with no issueID (skipped).
+  // The alfa act has no instances array, so it should be handled as empty.
+  assert.ok(issues.length >= 1);
+  const ids = issues.map(i => i.identifier);
+  assert.ok(ids.includes('duplicateID'));
+});

package/api/listReports.test.js

@@ -19,6 +19,8 @@ const fixtureIds = [
   ['260101T0002', 'no'],
   ['260101T0005', 'emp'],
   ['260101T0006', 'prv'],
+  ['260101T0008', 'mul'],
+  ['260101T0009', 'brd'],
   ['260202T0000', 'new']
 ];
 
@@ -41,10 +43,10 @@ after(() => {
 
 // TESTS
 
-test('listReports returns basics about all 6 non-hidden reports', async () => {
+test('listReports returns basics about all 8 non-hidden reports', async () => {
   const body = await response();
   const reportsBasics = body['response content']['basics about all available reports'];
-  assert.equal(reportsBasics.length, 6);
+  assert.equal(reportsBasics.length, 8);
   const ids = reportsBasics.map(b => b.identifier).sort();
   const expectedIds = fixtureIds.map(([ts, jid]) => `${ts}-${jid}`).sort();
   assert.deepEqual(ids, expectedIds);
@@ -66,9 +68,11 @@ test('listReports sorts reports by page description and then by completion time'
     descriptions,
     [
       'All CantTell Page',
+      'Branch Coverage Page',
       'Empty Results Page',
       'Mixed Outcomes Page',
       'Mixed Outcomes Page',
+      'Multi Violator Page',
       'No Outcomes Page',
       'Prevented Page'
     ]

package/api/listViolators.test.js

@@ -71,3 +71,38 @@ test('listViolators includes reporter facts for the issue', async () => {
   const names = reporters.map(r => r.name).sort();
   assert.deepEqual(names, ['Alfa', 'Axe']);
 });
+
+test('listViolators sorts by catalogIndex when two violators have the same reporter count', async () => {
+  const body = await response(['linkNoText', '260101T0008', 'mul']);
+  const violators = body['response content']['basics about all elements exhibiting the issue'];
+  assert.equal(violators.length, 3);
+  // The violator with 2 reporters (catalogIndex 2) sorts first.
+  assert.equal(violators[0].identifier, '2');
+  assert.equal(violators[0]['count of rule engines reporting that the element exhibited the issue'], 2);
+  // The two violators with 1 reporter each are sorted by catalogIndex ascending.
+  assert.equal(violators[1].identifier, '0');
+  assert.equal(violators[1]['count of rule engines reporting that the element exhibited the issue'], 1);
+  assert.equal(violators[2].identifier, '1');
+  assert.equal(violators[2]['count of rule engines reporting that the element exhibited the issue'], 1);
+});
+
+test('listViolators returns guideline layer for an issue with a short WCAG code', async () => {
+  const body = await response(['duplicateID', '260101T0009', 'brd']);
+  const issueBasics = body['response content']['basics about the issue'];
+  assert.equal(issueBasics['related WCAG standard'].layer, 'guideline');
+});
+
+test('listViolators returns null tag name and text for a violator not in the catalog', async () => {
+  const body = await response(['duplicateID', '260101T0009', 'brd']);
+  const violators = body['response content']['basics about all elements exhibiting the issue'];
+  const orphan = violators.find(v => v.identifier === '3');
+  assert.ok(orphan);
+  assert.equal(orphan['tag name'], null);
+  assert.equal(orphan['inner text'], null);
+});
+
+test('listViolators returns an error for a falsy issue ID', async () => {
+  const body = await response(['', '260101T0009', 'brd']);
+  const issueBasics = body['response content']['basics about the issue'];
+  assert.ok(issueBasics.error);
+});

package/api/requestTest.test.js

@@ -57,6 +57,13 @@ test('requestTest rejects a URL shorter than 12 characters', async () => {
   assert.equal(processTestRequestCalls.length, 0);
 });
 
+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'];
+  assert.ok(details.error.includes('invalid URL'));
+  assert.equal(processTestRequestCalls.length, 0);
+});
+
 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'];

package/api/routes.test.js

@@ -0,0 +1,63 @@
+/*
+  routes.test.js
+  Tests for api/routes.js, 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');
+
+// TESTS
+
+test('routes exports an array with 8 operations', () => {
+  assert.ok(Array.isArray(routes));
+  assert.equal(routes.length, 8);
+});
+
+test('routes includes all expected operation IDs', () => {
+  const ids = routes.map(r => r.operationId).sort();
+  assert.deepEqual(ids, [
+    'getReport',
+    'listDiagnoses',
+    'listIssues',
+    'listReports',
+    'listViolators',
+    'requestFeature',
+    'requestRetest',
+    'requestTest'
+  ]);
+});
+
+test('every route has a method, path, summary, and responseSchema', () => {
+  for (const route of routes) {
+    assert.ok(route.operationId, `route missing operationId: ${JSON.stringify(route)}`);
+    assert.ok(route.method, `route ${route.operationId} missing method`);
+    assert.ok(route.path, `route ${route.operationId} missing path`);
+    assert.ok(route.summary, `route ${route.operationId} missing summary`);
+    assert.ok(route.responseSchema, `route ${route.operationId} missing responseSchema`);
+  }
+});
+
+test('GET routes have pathParamsSchema when the path has parameters', () => {
+  for (const route of routes) {
+    if (route.method === 'get' && route.path.includes('{')) {
+      assert.ok(route.pathParamsSchema, `route ${route.operationId} missing pathParamsSchema`);
+    }
+  }
+});
+
+test('POST routes have bodySchema', () => {
+  for (const route of routes) {
+    if (route.method === 'post') {
+      assert.ok(route.bodySchema, `route ${route.operationId} missing bodySchema`);
+    }
+  }
+});
+
+test('route paths start with /api/', () => {
+  for (const route of routes) {
+    assert.ok(route.path.startsWith('/api/'), `route ${route.operationId} path does not start with /api/`);
+  }
+});

package/api/util.js

@@ -35,7 +35,7 @@ exports.getResponseMetadata = () => ({
 exports.getToolsFacts = () => ({
   'name': 'Kilotest',
   'description': {
-    'what Kilotest does': 'Kilotest tools generate and make available findings about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. A Kilotest job generates findings by using Testaro to test a page against more than a thousand rules defined by an ensemble of ten rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 300 issues. Kilotest makes facts about the issues and the violations retrievable at four levels of granularity.',
+    'what Kilotest does': 'Kilotest tools generate and make available findings about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. A Kilotest job generates findings by using Testaro to test a page against more than a thousand rules defined by an ensemble of twelve rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 300 issues. Kilotest makes facts about the issues and the violations retrievable at four levels of granularity.',
     'how to retrieve findings': {
       'level 1': 'Use the listReports tool to get a list of available reports.',
       'level 2': 'Use the listIssues tool to get a list of issues in one report.',
@@ -67,7 +67,7 @@ exports.getRuleEnginesFacts = ruleEngineIDSet => {
   objectSort(ruleEnginesFacts, 'name', 'alpha');
   return ruleEnginesFacts;
 };
-// Returns the basics about a report, without reading the report.
+// Returns the basics about a report.
 exports.getReportBasics = async (timeStamp, jobID) => {
   // Get the creation time of the report.
   const reportStats = await getReportStats(timeStamp, jobID);
@@ -79,24 +79,22 @@ exports.getReportBasics = async (timeStamp, jobID) => {
       error: `Report ${timeStamp}-${jobID} could not be retrieved.`
     };
   }
-  // Get an extract of the report.
+  // Otherwise, i.e. if it exists, get an extract of the report.
   const reportExtract = await getReportExtract(timeStamp, jobID);
-  // If no such report exists:
-  if (reportExtract.error) {
-    // Return this.
-    return reportExtract;
-  }
   const {url, what} = reportExtract;
   const latestReportExtracts = await getLatestReportExtracts();
   // Otherwise, i.e. if the report exists, get whether this report has been superseded.
   const isSuperseded = latestReportExtracts
   .every(extract => extract.timeStamp !== timeStamp || extract.jobID !== jobID);
-  const {reportTime} = reportStats;
+  // Get the completion time from the report content, not the file system birth time,
+  // because the birth time depends on when the file was created on the file system
+  // and does not reflect the actual report completion time.
+  const {reportTime} = reportExtract;
   // Get the basics about the report.
   const basics = {
     identifier: `${timeStamp}-${jobID}`,
-    'completion date and time': reportTime.toISOString(),
-    'days since the report was completed': getAgoDays(reportTime),
+    'completion date and time': reportTime,
+    'days since the report was completed': getAgoDays(new Date(reportTime)),
     'tested web page': {
       description: what,
       URL: url

package/api/util.test.js

@@ -7,9 +7,12 @@
 
 const {test} = require('node:test');
 const assert = require('node:assert/strict');
-const {getRuleEngineFacts, getRuleEnginesFacts} = require('./util');
+const path = require('node:path');
+const {getReportBasics, getResponseMetadata, getRuleEngineFacts, getRuleEnginesFacts, getIssueSpec, getToolsFacts, processTestRequest} = require('./util');
 
-// TESTS
+// SETUP
+
+const savedDBDir = process.env.DB_DIR;
 
 test('getRuleEngineFacts returns the name and sponsor of a known rule engine', () => {
   const facts = getRuleEngineFacts('axe');
@@ -40,3 +43,66 @@ test('getRuleEnginesFacts returns an empty array for an empty set', () => {
   const facts = getRuleEnginesFacts(new Set());
   assert.deepEqual(facts, []);
 });
+
+test('getIssueSpec returns a specification for a known non-ignorable issue', () => {
+  const spec = getIssueSpec('linkNoText');
+  assert.ok(spec);
+  assert.ok(spec.summary);
+  assert.ok(spec.wcag);
+  assert.ok([1, 2, 3, 4].includes(spec.weight));
+  assert.ok(spec.why);
+});
+
+test('getIssueSpec returns null for an unknown issue ID', () => {
+  const spec = getIssueSpec('nonexistentIssue');
+  assert.equal(spec, null);
+});
+
+test('getIssueSpec returns null for the ignorable issue ID', () => {
+  const spec = getIssueSpec('ignorable');
+  assert.equal(spec, null);
+});
+
+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');
+  assert.ok(basics.error);
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+test('processTestRequest returns an error for a duplicate recommendation', async () => {
+  process.env.DB_DIR = path.join(__dirname, '..', 'test', 'fixtures', 'db');
+  // 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');
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+test('getResponseMetadata returns an identifier and date string', () => {
+  const meta = getResponseMetadata();
+  assert.ok(meta.identifier);
+  assert.ok(meta.identifier.includes('-'));
+  assert.ok(meta['date and time']);
+  assert.equal(typeof meta['date and time'], 'string');
+});
+
+test('getToolsFacts returns facts about the Kilotest tool collection', () => {
+  const facts = getToolsFacts();
+  assert.equal(facts.name, 'Kilotest');
+  assert.ok(facts.description);
+  assert.ok(facts.description['what Kilotest does']);
+  assert.ok(facts.description['how to retrieve findings']);
+  assert.ok(facts.description['how to generate more findings']);
+});

package/apiIntegration.test.js

@@ -23,7 +23,7 @@ let server;
 before(async () => {
   process.env.DB_DIR = path.join(__dirname, 'test', 'fixtures', 'db');
   server = http.createServer(requestHandler);
-  await new Promise(resolve => server.listen(port, resolve));
+  await new Promise(resolve => server.listen(port, () => resolve()));
 });
 
 after(async () => {
@@ -33,7 +33,17 @@ after(async () => {
   else {
     delete process.env.DB_DIR;
   }
-  await new Promise(resolve => server.close(() => resolve()));
+  server.closeAllConnections?.();
+  await new Promise(resolve => {
+    const timer = setTimeout(() => {
+      server.closeAllConnections?.();
+      resolve();
+    }, 1000);
+    server.close(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
 });
 
 // HELPERS
@@ -71,7 +81,7 @@ test('GET /api/listReports returns valid JSON through the HTTP routing layer', a
   const {body} = await request('GET', '/api/listReports');
   assert.equal(body['tool name'], 'listReports');
   const reports = body['response content']['basics about all available reports'];
-  assert.equal(reports.length, 6);
+  assert.equal(reports.length, 8);
 });
 
 test('POST /api/requestFeature parses a JSON body and returns a JSON response through the HTTP routing layer', async () => {