tests: fixed up tests using workers

Author: tegefaulkes

Diff for: src/DB.ts

@@ -695,10 +695,10 @@ class DB {
         const cipherText = utils.toArrayBuffer(cipherTextBuf);
         const result = await this.workerManager.methods.decrypt(
           {
-            key: this.crypto.key,
-            cipherText: cipherTextBuf,
+            key,
+            cipherText,
           },
-          [this.crypto.key, cipherTextBuf],
+          [key, cipherText],
         );
         decrypted = result.data;
       } else {

Diff for: src/exampleDbWorker.ts

@@ -0,0 +1,99 @@
+import type { Crypto } from '#types.js';
+import type { WorkerManifest } from '@matrixai/workers';
+import { expose } from '@matrixai/workers';
+import nodeForge from 'node-forge';
+
+const { random, cipher, util: forgeUtil } = nodeForge;
+const ivSize = 16;
+const authTagSize = 16;
+
+function getRandomBytesSync(size: number): Buffer {
+  return Buffer.from(random.getBytesSync(size), 'binary');
+}
+
+async function encrypt(
+  key: ArrayBuffer,
+  plainText: ArrayBuffer,
+): Promise<ArrayBuffer> {
+  const iv = getRandomBytesSync(ivSize);
+  const c = cipher.createCipher('AES-GCM', Buffer.from(key).toString('binary'));
+  c.start({ iv: iv.toString('binary'), tagLength: authTagSize * 8 });
+  c.update(forgeUtil.createBuffer(plainText));
+  c.finish();
+  const cipherText = Buffer.from(c.output.getBytes(), 'binary');
+  const authTag = Buffer.from(c.mode.tag.getBytes(), 'binary');
+  const data = Buffer.concat([iv, authTag, cipherText]);
+  return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+
+async function decrypt(
+  key: ArrayBuffer,
+  cipherText: ArrayBuffer,
+): Promise<ArrayBuffer | undefined> {
+  const cipherTextBuf = Buffer.from(cipherText);
+  if (cipherTextBuf.byteLength < 32) {
+    return;
+  }
+  const iv = cipherTextBuf.subarray(0, ivSize);
+  const authTag = cipherTextBuf.subarray(ivSize, ivSize + authTagSize);
+  const cipherText_ = cipherTextBuf.subarray(ivSize + authTagSize);
+  const d = cipher.createDecipher(
+    'AES-GCM',
+    Buffer.from(key).toString('binary'),
+  );
+  d.start({
+    iv: iv.toString('binary'),
+    tagLength: authTagSize * 8,
+    tag: forgeUtil.createBuffer(authTag),
+  });
+  d.update(forgeUtil.createBuffer(cipherText_));
+  if (!d.finish()) {
+    return;
+  }
+  const data = Buffer.from(d.output.getBytes(), 'binary');
+  return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+
+const exampleDbWorker: Crypto = {
+  async encrypt(
+    {
+      key,
+      plainText,
+    }: {
+      key: ArrayBuffer;
+      plainText: ArrayBuffer;
+    },
+    transferList: [ArrayBuffer, ArrayBuffer], // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<{ data: ArrayBuffer; transferList: [ArrayBuffer] }> {
+    const cipherText = await encrypt(key, plainText);
+    return { data: cipherText, transferList: [cipherText] };
+  },
+  async decrypt(
+    {
+      key,
+      cipherText,
+    }: {
+      key: ArrayBuffer;
+      cipherText: ArrayBuffer;
+    },
+    transferList: [ArrayBuffer, ArrayBuffer], // eslint-disable-line @typescript-eslint/no-unused-vars
+  ): Promise<
+    | { data: ArrayBuffer; transferList: [ArrayBuffer] }
+    | { data: undefined; transferList: [] }
+  > {
+    const plainText = await decrypt(key, cipherText);
+    if (plainText != null) {
+      return { data: plainText, transferList: [plainText] };
+    } else {
+      return { data: undefined, transferList: [] };
+    }
+  },
+} satisfies WorkerManifest;
+
+expose(exampleDbWorker);
+
+type ExampleDBWorker = typeof exampleDbWorker;
+
+export type { ExampleDBWorker };
+
+export default exampleDbWorker;

Diff for: tests/DB.test.ts

@@ -1,34 +1,40 @@
 import type DBTransaction from '#DBTransaction.js';
 import type { KeyPath } from '#types.js';
 import type { ResourceRelease } from '@matrixai/resources';
-import type { DBWorker } from './workers/dbWorker.js';
+import type { ExampleDBWorker } from '#exampleDbWorker.js';
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 import nodeCrypto from 'node:crypto';
 import { Worker } from 'node:worker_threads';
+import url from 'node:url';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
 import { WorkerManager } from '@matrixai/workers';
 import { withF } from '@matrixai/resources';
 import * as testsUtils from './utils.js';
-import dbWorker from './workers/dbWorker.js';
+import exampleDbWorker from '#exampleDbWorker.js';
 import DB from '#DB.js';
 import * as errors from '#errors.js';
 import * as utils from '#utils.js';
 
+const dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
 describe(DB.name, () => {
   const logger = new Logger(`${DB.name} Test`, LogLevel.WARN, [
     new StreamHandler(),
   ]);
   const crypto = {
     key: testsUtils.generateKeySync(256),
-    ops: dbWorker,
+    ops: exampleDbWorker,
   };
   let dataDir: string;
+  let workerManager: WorkerManager<ExampleDBWorker>;
+
   beforeEach(async () => {
     dataDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'db-test-'));
   });
   afterEach(async () => {
+    await workerManager?.destroy({ force: true });
     await fs.promises.rm(dataDir, {
       force: true,
       recursive: true,
@@ -341,10 +347,11 @@ describe(DB.name, () => {
   test('parallelized get and put and del', async () => {
     const dbPath = `${dataDir}/db`;
     const db = await DB.createDB({ dbPath, crypto, logger });
-    const workerManager = await WorkerManager.createWorkerManager<DBWorker>({
-      workerFactory: () => new Worker('./workers/dbWorker'),
+    workerManager = await WorkerManager.createWorkerManager({
+      workerFactory: () =>
+        new Worker(path.join(dirname, '../dist/exampleDbWorker')),
       cores: 1,
-      manifest: dbWorker,
+      manifest: exampleDbWorker,
       logger,
     });
     db.setWorkerManager(workerManager);
@@ -403,10 +410,11 @@ describe(DB.name, () => {
   test('parallelized batch put and del', async () => {
     const dbPath = `${dataDir}/db`;
     const db = await DB.createDB({ dbPath, crypto, logger });
-    const workerManager = await WorkerManager.createWorkerManager<DBWorker>({
-      workerFactory: () => new Worker('./workers/dbWorker'),
+    const workerManager = await WorkerManager.createWorkerManager({
+      workerFactory: () =>
+        new Worker(path.join(dirname, '../dist/exampleDbWorker')),
       cores: 4,
-      manifest: dbWorker,
+      manifest: exampleDbWorker,
       logger,
     });
     db.setWorkerManager(workerManager);

Diff for: tests/DBIterator.test.ts

@@ -7,7 +7,7 @@ import nodeUtil from 'util';
 import lexi from 'lexicographic-integer';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
 import * as testsUtils from './utils.js';
-import dbWorker from './workers/dbWorker.js';
+import exampleDbWorker from '#exampleDbWorker.js';
 import DB from '#DB.js';
 import DBIterator from '#DBIterator.js';
 import rocksdbP from '#native/rocksdbP.js';
@@ -18,7 +18,7 @@ describe(DBIterator.name, () => {
   ]);
   const crypto = {
     key: testsUtils.generateKeySync(256),
-    ops: dbWorker,
+    ops: exampleDbWorker,
   };
   let dataDir: string;
   let db: DB;

Diff for: tests/DBTransaction.test.ts

@@ -6,7 +6,7 @@ import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
 import { withF } from '@matrixai/resources';
 import { Barrier, errors as locksErrors } from '@matrixai/async-locks';
 import * as testsUtils from './utils.js';
-import dbWorker from './workers/dbWorker.js';
+import exampleDbWorker from '#exampleDbWorker.js';
 import DB from '#DB.js';
 import DBTransaction from '#DBTransaction.js';
 import * as errors from '#errors.js';
@@ -17,7 +17,7 @@ describe(DBTransaction.name, () => {
   ]);
   const crypto = {
     key: testsUtils.generateKeySync(256),
-    ops: dbWorker,
+    ops: exampleDbWorker,
   };
   let dataDir: string;
   let db: DB;