@jrpool/kilotest 46.0.8 → 46.0.14

package/indexBalances.test.js

@@ -0,0 +1,188 @@
+/*
+  indexBalances.test.js
+  Tests for checkBalancesForAlerts in index.js, which requires balance-related
+  env vars to be set before index.js is loaded.
+*/
+
+// ENVIRONMENT (must be set before requiring index.js)
+
+const path = require('node:path');
+const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+
+process.env.DB_DIR = fixtureDBDir;
+process.env.AUTH_CODE = 'test-auth-code';
+process.env.TESTARO_WORKERS = JSON.stringify({
+  worker1: {secret: 'secret1', name: 'Worker One'}
+});
+process.env.WAVE_BALANCE_THRESHOLD = '100';
+process.env.AI_SERVICE0_BALANCE_THRESHOLD = '50';
+process.env.AI_MODEL0_INPUT_PRICE = '0.001';
+process.env.AI_MODEL0_OUTPUT_PRICE = '0.002';
+
+const {test, before, after} = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const fs = require('node:fs/promises');
+const {requestHandler} = require('./index');
+
+// CONSTANTS
+
+const port = 3994;
+const balancePath = path.join(__dirname, 'ai0Balance.json');
+const jobID = '990101T0001-bal';
+const reportPath = path.join(fixtureDBDir, 'reports', `${jobID}.json`);
+const claimedDir = path.join(fixtureDBDir, 'jobs', 'claimed');
+const jobPath = path.join(claimedDir, `${jobID}.json`);
+
+// SETUP AND TEARDOWN
+
+let server;
+let originalBalance;
+
+before(async () => {
+  originalBalance = await fs.readFile(balancePath, 'utf8').catch(() => null);
+  server = http.createServer(requestHandler);
+  await new Promise(resolve => server.listen(port, () => resolve()));
+});
+
+after(async () => {
+  server.closeAllConnections?.();
+  await new Promise(resolve => {
+    const timer = setTimeout(() => {
+      server.closeAllConnections?.();
+      resolve();
+    }, 1000);
+    server.close(() => {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+  if (originalBalance !== null) {
+    await fs.writeFile(balancePath, originalBalance);
+  }
+  else {
+    await fs.unlink(balancePath).catch(() => {});
+  }
+  // Clean up any report and job files created by tests.
+  await fs.unlink(reportPath).catch(() => {});
+  await fs.unlink(jobPath).catch(() => {});
+});
+
+// HELPERS
+
+const request = (method, requestPath, body = null, headers = {}) => new Promise((resolve, reject) => {
+  const options = {method, host: 'localhost', port, path: requestPath, headers: {...headers}};
+  let bodyData = '';
+  if (body) {
+    bodyData = JSON.stringify(body);
+    options.headers['content-type'] = 'application/json';
+    options.headers['content-length'] = Buffer.byteLength(bodyData);
+  }
+  const req = http.request(options, response => {
+    const chunks = [];
+    response.on('data', chunk => chunks.push(chunk));
+    response.on('end', () => {
+      resolve({statusCode: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString()});
+    });
+  });
+  req.on('error', reject);
+  req.end(bodyData || '');
+});
+
+const jsonBody = res => {
+  try {
+    return JSON.parse(res.body);
+  }
+  catch {
+    return null;
+  }
+};
+
+const submitReport = async (acts, balanceFileContent) => {
+  if (balanceFileContent !== undefined) {
+    if (balanceFileContent === null) {
+      await fs.unlink(balancePath).catch(() => {});
+    }
+    else {
+      await fs.writeFile(balancePath, balanceFileContent);
+    }
+  }
+  await fs.writeFile(jobPath, JSON.stringify({
+    id: jobID,
+    target: {what: 'Test', url: 'https://example.com/test'},
+    sources: {worker: 'Worker One'}
+  }));
+  const auth = Buffer.from('worker1:secret1').toString('base64');
+  const report = {
+    id: jobID,
+    target: {what: 'Test', url: 'https://example.com/test'},
+    acts,
+    jobData: {endTime: '26-01-01T00:00'},
+    catalog: {}
+  };
+  const res = await request('POST', '/worker/report', {report}, {
+    authorization: `Basic ${auth}`
+  });
+  await fs.unlink(jobPath).catch(() => {});
+  await fs.unlink(reportPath).catch(() => {});
+  return res;
+};
+
+// TESTS
+
+test('worker/report with WAVE balance low triggers a balance alert', async () => {
+  const res = await submitReport(
+    [
+      {type: 'test', which: 'wave', data: {creditsRemaining: 5}},
+      {type: 'test', which: 'testaro', data: {ruleData: {allCaps: {aiModelUsage: {inputTokens: 100, outputTokens: 50}}}}}
+    ],
+    JSON.stringify({balance: 100})
+  );
+  assert.equal(res.statusCode, 200);
+  const body = jsonBody(res);
+  assert.equal(body.status, 'ok');
+});
+
+test('worker/report with AI service balance low triggers a balance alert', async () => {
+  const res = await submitReport(
+    [
+      {type: 'test', which: 'wave', data: {creditsRemaining: 200}},
+      {type: 'test', which: 'testaro', data: {ruleData: {allCaps: {aiModelUsage: {inputTokens: 5000, outputTokens: 3000}}}}}
+    ],
+    JSON.stringify({balance: 10})
+  );
+  assert.equal(res.statusCode, 200);
+});
+
+test('worker/report with no balance file logs an error', async () => {
+  const res = await submitReport(
+    [
+      {type: 'test', which: 'wave', data: {creditsRemaining: 200}},
+      {type: 'test', which: 'testaro', data: {ruleData: {allCaps: {aiModelUsage: {inputTokens: 100, outputTokens: 50}}}}}
+    ],
+    null
+  );
+  assert.equal(res.statusCode, 200);
+});
+
+test('worker/report with invalid balance JSON logs an error', async () => {
+  const res = await submitReport(
+    [
+      {type: 'test', which: 'wave', data: {creditsRemaining: 200}},
+      {type: 'test', which: 'testaro', data: {ruleData: {allCaps: {aiModelUsage: {inputTokens: 100, outputTokens: 50}}}}}
+    ],
+    'not valid json'
+  );
+  assert.equal(res.statusCode, 200);
+});
+
+test('worker/report with non-number balance logs an error', async () => {
+  const res = await submitReport(
+    [
+      {type: 'test', which: 'wave', data: {creditsRemaining: 200}},
+      {type: 'test', which: 'testaro', data: {ruleData: {allCaps: {aiModelUsage: {inputTokens: 100, outputTokens: 50}}}}}
+    ],
+    JSON.stringify({balance: 'not a number'})
+  );
+  assert.equal(res.statusCode, 200);
+});

package/indexFallback.test.js

@@ -0,0 +1,33 @@
+/*
+  indexFallback.test.js
+  Tests that index.js loads successfully when PROTOCOL and TESTARO_WORKERS
+  are not set, exercising the || fallback branches at module load time.
+  This must be a separate file because index.js reads these env vars
+  at module load time, and each test file runs in its own process.
+*/
+
+// ENVIRONMENT (must be set before requiring index.js)
+
+const path = require('node:path');
+const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+
+process.env.DB_DIR = fixtureDBDir;
+process.env.AUTH_CODE = 'test-auth-code';
+// Set PROTOCOL and TESTARO_WORKERS to empty strings (falsy) so that
+// the || fallbacks in index.js are exercised. dotenv does not override
+// existing env vars, so .env will not replace these.
+process.env.PROTOCOL = '';
+process.env.TESTARO_WORKERS = '';
+
+// IMPORTS
+
+const {test} = require('node:test');
+const assert = require('node:assert/strict');
+const {requestHandler} = require('./index');
+
+// TESTS
+
+test('index.js loads with empty PROTOCOL and TESTARO_WORKERS using fallbacks', () => {
+  // If index.js loaded successfully, requestHandler is a function.
+  assert.equal(typeof requestHandler, 'function');
+});

package/indexServe.test.js

@@ -0,0 +1,59 @@
+/*
+  indexServe.test.js
+  Tests for the serve function in index.js, which starts the HTTP or HTTPS
+  server. The serve function is exported for testing.
+*/
+
+// ENVIRONMENT (must be set before requiring index.js)
+
+const path = require('node:path');
+const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+
+process.env.DB_DIR = fixtureDBDir;
+process.env.AUTH_CODE = 'test-auth-code';
+process.env.TESTARO_WORKERS = '{}';
+
+const {test} = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const fs = require('node:fs/promises');
+const {serve} = require('./index');
+
+// HELPER
+
+const closeServer = server => new Promise(resolve => {
+  if (!server) {
+    resolve();
+    return;
+  }
+  // Close all idle connections, then close the server.
+  server.closeAllConnections?.();
+  const timer = setTimeout(() => {
+    server.closeAllConnections?.();
+    resolve();
+  }, 500);
+  server.close(() => {
+    clearTimeout(timer);
+    resolve();
+  });
+});
+
+// TESTS
+
+test('serve creates missing directories and returns an HTTP server', async () => {
+  // Remove the queue directory to verify serve recreates it.
+  const queueDir = path.join(fixtureDBDir, 'jobs', 'queue');
+  await fs.rm(queueDir, {recursive: true}).catch(() => {});
+  process.env.PORT = '3987';
+  const server = await serve(http, {});
+  try {
+    assert.ok(server);
+    assert.equal(typeof server.listen, 'function');
+    // Verify the queue directory was recreated.
+    const exists = await fs.access(queueDir).then(() => true).catch(() => false);
+    assert.ok(exists, 'serve should create the queue directory');
+  }
+  finally {
+    await closeServer(server);
+  }
+});

package/indexWorkers.test.js

@@ -0,0 +1,79 @@
+/*
+  indexWorkers.test.js
+  Tests for index.js when TESTARO_WORKERS is invalid JSON.
+  This must be a separate file because index.js reads TESTARO_WORKERS
+  at module load time.
+*/
+
+// ENVIRONMENT (must be set before requiring index.js)
+
+const path = require('node:path');
+const fixtureDBDir = path.join(__dirname, 'test', 'fixtures', 'db');
+
+process.env.DB_DIR = fixtureDBDir;
+process.env.AUTH_CODE = 'test-auth-code';
+process.env.TESTARO_WORKERS = 'not valid json';
+
+// IMPORTS
+
+const {test} = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const {requestHandler} = require('./index');
+
+// CONSTANTS
+
+const port = 3993;
+
+// HELPERS
+
+const request = (method, requestPath, body = null, headers = {}) => new Promise((resolve, reject) => {
+  const options = {method, host: 'localhost', port, path: requestPath, headers: {...headers}};
+  let bodyData = '';
+  if (body) {
+    bodyData = JSON.stringify(body);
+    options.headers['content-type'] = 'application/json';
+    options.headers['content-length'] = Buffer.byteLength(bodyData);
+  }
+  const req = http.request(options, response => {
+    const chunks = [];
+    response.on('data', chunk => chunks.push(chunk));
+    response.on('end', () => {
+      resolve({statusCode: response.statusCode, headers: response.headers, body: Buffer.concat(chunks).toString()});
+    });
+  });
+  req.on('error', reject);
+  req.end(bodyData || '');
+});
+
+// TESTS
+
+test('index.js loads with invalid TESTARO_WORKERS and treats workers as empty', () => {
+  // If index.js loaded successfully, requestHandler is a function.
+  assert.equal(typeof requestHandler, 'function');
+});
+
+test('POST /worker/job with invalid TESTARO_WORKERS returns 401 for any credentials', async () => {
+  const server = http.createServer(requestHandler);
+  await new Promise(resolve => server.listen(port, () => resolve()));
+  try {
+    const auth = Buffer.from('worker1:secret1').toString('base64');
+    const res = await request('POST', '/worker/job', {}, {
+      authorization: `Basic ${auth}`
+    });
+    assert.equal(res.statusCode, 401);
+  }
+  finally {
+    server.closeAllConnections?.();
+    await new Promise(resolve => {
+      const timer = setTimeout(() => {
+        server.closeAllConnections?.();
+        resolve();
+      }, 1000);
+      server.close(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+});