test(nodejs): unit tests

eslint.config.mjs

@@ -183,6 +183,24 @@ const config = createConfig([
       globals: { lockdown: 'readonly' },
     },
   },
+
+  {
+    files: [
+      'packages/nodejs/**/*-worker.ts',
+      'packages/nodejs/test/workers/**/*',
+    ],
+    rules: {
+      // Node workers have reasonable cause to read from process.env
+      'n/no-process-env': 'off',
+    },
+  },
+  {
+    files: ['packages/nodejs/test/workers/**/*'],
+    rules: {
+      // Test node worker files can resolve these imports, even if eslint cannot.
+      'import-x/no-unresolved': 'off',
+    },
+  },
 ]);
 
 export default config;

package.json

@@ -33,7 +33,8 @@
     "prepack": "./scripts/prepack.sh",
     "test": "vitest run",
     "test:clean": "yarn test --no-cache --coverage.clean",
-    "test:dev": "yarn test --coverage false ",
+    "test:dev": "yarn test --coverage false",
+    "test:e2e": "yarn workspaces foreach --all run test:e2e",
     "test:e2e:ci": "yarn workspaces foreach --all run test:e2e:ci",
     "test:verbose": "yarn test --reporter verbose",
     "test:watch": "vitest",

packages/nodejs/package.json

@@ -34,7 +34,7 @@
     "publish:preview": "yarn npm publish --tag preview",
     "test": "vitest run --config vitest.config.ts",
     "test:e2e": "vitest run --config vitest.config.e2e.ts",
-    "test:e2e:ci": "echo 'skipped tests' || ./scripts/test-e2e-ci.sh",
+    "test:e2e:ci": "./scripts/test-e2e-ci.sh",
     "test:clean": "yarn test --no-cache --coverage.clean",
     "test:dev": "yarn test --coverage false",
     "test:verbose": "yarn test --reporter verbose",
@@ -47,6 +47,7 @@
     "@metamask/eslint-config-nodejs": "^14.0.0",
     "@metamask/eslint-config-typescript": "^14.0.0",
     "@ocap/cli": "workspace:^",
+    "@ocap/test-utils": "workspace:^",
     "@ts-bridge/cli": "^0.6.2",
     "@ts-bridge/shims": "^0.1.1",
     "@types/better-sqlite3": "^7.6.12",
@@ -77,7 +78,6 @@
   },
   "dependencies": {
     "@endo/promise-kit": "^1.1.6",
-    "@metamask/utils": "^11.0.1",
     "@ocap/kernel": "workspace:^",
     "@ocap/shims": "workspace:^",
     "@ocap/streams": "workspace:^",

packages/nodejs/src/kernel/VatWorkerService.test.ts

@@ -1,12 +1,106 @@
 import '@ocap/shims/endoify';
 
-import { describe, expect, it } from 'vitest';
+import type { VatId } from '@ocap/kernel';
+import { makeCounter } from '@ocap/utils';
+import { describe, expect, it, vi } from 'vitest';
 
 import { NodejsVatWorkerService } from './VatWorkerService.js';
 
+const mocks = vi.hoisted(() => ({
+  worker: {
+    once: (_: string, callback: () => unknown) => {
+      callback();
+    },
+    terminate: vi.fn(async () => undefined),
+  },
+  stream: {
+    synchronize: vi.fn(async () => undefined).mockResolvedValue(undefined),
+    return: vi.fn(async () => ({})),
+  },
+}));
+
+vi.mock('@ocap/streams', () => ({
+  NodeWorkerDuplexStream: vi.fn(() => mocks.stream),
+}));
+
+vi.mock('node:worker_threads', () => ({
+  Worker: vi.fn(() => mocks.worker),
+}));
+
 describe('NodejsVatWorkerService', () => {
   it('constructs an instance without any arguments', () => {
-    const instance = new NodejsVatWorkerService();
+    const instance = new NodejsVatWorkerService({});
     expect(instance).toBeInstanceOf(NodejsVatWorkerService);
   });
+
+  const workerFilePath = 'unused';
+  const vatIdCounter = makeCounter();
+  const getTestVatId = (): VatId => `v${vatIdCounter()}`;
+
+  describe('launch', () => {
+    it('creates a NodeWorker and returns a NodeWorkerDuplexStream', async () => {
+      const service = new NodejsVatWorkerService({
+        workerFilePath,
+      });
+      const testVatId: VatId = getTestVatId();
+      const stream = await service.launch(testVatId);
+
+      expect(stream).toStrictEqual(mocks.stream);
+    });
+
+    it('rejects if synchronize fails', async () => {
+      const rejected = 'test-reject-value';
+      mocks.stream.synchronize.mockRejectedValue(rejected);
+      const service = new NodejsVatWorkerService({ workerFilePath });
+      const testVatId: VatId = getTestVatId();
+      await expect(async () => await service.launch(testVatId)).rejects.toThrow(
+        rejected,
+      );
+    });
+  });
+
+  describe('terminate', () => {
+    it('terminates the target vat', async () => {
+      const service = new NodejsVatWorkerService({
+        workerFilePath,
+      });
+      const testVatId: VatId = getTestVatId();
+
+      await service.launch(testVatId);
+      expect(service.workers.has(testVatId)).toBe(true);
+
+      await service.terminate(testVatId);
+      expect(service.workers.has(testVatId)).toBe(false);
+    });
+
+    it('throws when terminating an unknown vat', async () => {
+      const service = new NodejsVatWorkerService({
+        workerFilePath,
+      });
+      const testVatId: VatId = getTestVatId();
+
+      await expect(
+        async () => await service.terminate(testVatId),
+      ).rejects.toThrow(/No worker found/u);
+    });
+  });
+
+  describe('terminateAll', () => {
+    it('terminates all vats', async () => {
+      const service = new NodejsVatWorkerService({
+        workerFilePath,
+      });
+      const vatIds: VatId[] = [getTestVatId(), getTestVatId(), getTestVatId()];
+
+      await Promise.all(
+        vatIds.map(async (vatId) => await service.launch(vatId)),
+      );
+
+      expect(Array.from(service.workers.values())).toHaveLength(vatIds.length);
+
+      await service.terminateAll();
+
+      expect(Array.from(service.workers.values())).toHaveLength(0);
+    });
+  });
 });

packages/nodejs/src/kernel/VatWorkerService.ts

@@ -14,12 +14,16 @@ import { Worker as NodeWorker } from 'node:worker_threads';
 
 // Worker file loads from the built dist directory, requires rebuild after change
 // Note: Worker runs in same process and may be subject to spectre-style attacks
-const workerFileURL = new URL('../../dist/vat/vat-worker.mjs', import.meta.url)
-  .pathname;
+const DEFAULT_WORKER_FILE = new URL(
+  '../../dist/vat/vat-worker.mjs',
+  import.meta.url,
+).pathname;
 
 export class NodejsVatWorkerService implements VatWorkerService {
   readonly #logger: Logger;
 
+  readonly #workerFilePath: string;
+
   workers = new Map<
     VatId,
     { worker: NodeWorker; stream: DuplexStream<VatCommandReply, VatCommand> }
@@ -29,24 +33,29 @@ export class NodejsVatWorkerService implements VatWorkerService {
    * The vat worker service, intended to be constructed in
    * the kernel worker.
    *
-   * @param logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'.
+   * @param args - A bag of optional arguments.
+   * @param args.workerFilePath - An optional path to a file defining the worker's routine. Defaults to 'vat-worker.mjs'.
+   * @param args.logger - An optional {@link Logger}. Defaults to a new logger labeled '[vat worker client]'.
    */
-  constructor(logger?: Logger) {
-    this.#logger = logger ?? makeLogger('[vat worker service]');
+  constructor(args: {
+    workerFilePath?: string | undefined;
+    logger?: Logger | undefined;
+  }) {
+    this.#workerFilePath = args.workerFilePath ?? DEFAULT_WORKER_FILE;
+    this.#logger = args.logger ?? makeLogger('[vat worker service]');
   }
 
   async launch(
     vatId: VatId,
   ): Promise<DuplexStream<VatCommandReply, VatCommand>> {
+    this.#logger.debug('launching vat', vatId);
     const { promise, resolve, reject } =
       makePromiseKit<DuplexStream<VatCommandReply, VatCommand>>();
-    this.#logger.debug('launching', vatId);
-    const worker = new NodeWorker(workerFileURL, {
+    const worker = new NodeWorker(this.#workerFilePath, {
       env: {
         NODE_VAT_ID: vatId,
       },
     });
-    this.#logger.debug('launched', vatId);
     worker.once('online', () => {
       const stream = new NodeWorkerDuplexStream<VatCommandReply, VatCommand>(
         worker,
@@ -57,7 +66,7 @@ export class NodejsVatWorkerService implements VatWorkerService {
         .synchronize()
         .then(() => {
           resolve(stream);
-          this.#logger.debug('connected', vatId);
+          this.#logger.debug('connected to kernel');
           return undefined;
         })
         .catch((error) => {

packages/nodejs/src/kernel/make-kernel.test.ts

@@ -0,0 +1,31 @@
+import '@ocap/shims/endoify';
+
+import { Kernel } from '@ocap/kernel';
+import {
+  MessagePort as NodeMessagePort,
+  MessageChannel as NodeMessageChannel,
+} from 'node:worker_threads';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { makeKernel } from './make-kernel.js';
+
+vi.mock('./sqlite-kv-store.js', async () => {
+  const { makeMapKVStore } = await import('../../../kernel/test/storage.js');
+  return {
+    makeSQLKVStore: makeMapKVStore,
+  };
+});
+
+describe('makeKernel', () => {
+  let kernelPort: NodeMessagePort;
+
+  beforeEach(() => {
+    kernelPort = new NodeMessageChannel().port1;
+  });
+
+  it('should return a Kernel', async () => {
+    const kernel = await makeKernel(kernelPort);
+
+    expect(kernel).toBeInstanceOf(Kernel);
+  });
+});

packages/nodejs/src/kernel/make-kernel.ts

@@ -0,0 +1,34 @@
+import type { KernelCommand, KernelCommandReply } from '@ocap/kernel';
+import { Kernel } from '@ocap/kernel';
+import { NodeWorkerDuplexStream } from '@ocap/streams';
+import { MessagePort as NodeMessagePort } from 'node:worker_threads';
+
+import { makeSQLKVStore } from './sqlite-kv-store.js';
+import { NodejsVatWorkerService } from './VatWorkerService.js';
+
+/**
+ * The main function for the kernel worker.
+ *
+ * @param port - The kernel's end of a node:worker_threads MessageChannel
+ * @param workerFilePath - The path to a file defining each vat worker's routine.
+ * @returns The kernel, initialized.
+ */
+export async function makeKernel(
+  port: NodeMessagePort,
+  workerFilePath?: string,
+): Promise<Kernel> {
+  const nodeStream = new NodeWorkerDuplexStream<
+    KernelCommand,
+    KernelCommandReply
+  >(port);
+  const vatWorkerClient = new NodejsVatWorkerService({ workerFilePath });
+
+  // Initialize kernel store.
+  const kvStore = await makeSQLKVStore();
+
+  // Create and start kernel.
+  const kernel = new Kernel(nodeStream, vatWorkerClient, kvStore);
+  await kernel.init();
+
+  return kernel;
+}