Test for core count of 0 results in useless worker pool

Author: CMCDragonkai

src/WorkerManager.ts

@@ -19,6 +19,8 @@ class WorkerManager<W extends ModuleMethods>
    * The `workerPath` can be either an absolute path or relative path
    * If it is a relative path, it has to be relative to the file location where
    * the function expression is defined
+   * If `cores` is set to 0, this creates a useless worker pool
+   * Use `undefined` to mean using all cores
    */
   public static async createWorkerManager<W extends ModuleMethods>({
     workerFactory,
@@ -64,12 +66,14 @@ class WorkerManager<W extends ModuleMethods>
     return this._destroyed;
   }
 
-  public async destroy(): Promise<void> {
+  public async destroy({
+    force = false,
+  }: { force?: boolean } = {}): Promise<void> {
     if (this._destroyed) {
       return;
     }
     this.logger.info('Destroying WorkerManager');
-    await this.pool.terminate();
+    await this.pool.terminate(force);
     this._running = false;
     this._destroyed = true;
     this.logger.info('Destroyed WorkerManager');

tests/WorkerManager.test.ts

@@ -1,9 +1,10 @@
 import type { WorkerModule } from '@/worker';
-
+import os from 'os';
 import { spawn, Worker, Transfer } from 'threads';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
 import WorkerManager from '@/WorkerManager';
 import * as errors from '@/errors';
+import * as testUtils from './utils';
 
 describe('WorkerManager', () => {
   const logger = new Logger('WorkerManager Test', LogLevel.WARN, [
@@ -26,7 +27,25 @@ describe('WorkerManager', () => {
       errors.ErrorWorkerManagerNotRunning,
     );
   });
-  test('start with just 1 worker core', async () => {
+  test('starting with 0 worker cores is useless', async () => {
+    const workerManager = await WorkerManager.createWorkerManager<WorkerModule>(
+      {
+        workerFactory: () => spawn(new Worker('../src/worker')),
+        cores: 0,
+        logger,
+      },
+    );
+    // The call will never resolve, so we timeout in 1 second
+    expect(
+      await Promise.race([
+        workerManager.call(async () => 1),
+        testUtils.sleep(1000),
+      ]),
+    ).not.toBe(1);
+    // Force destory because of the pending call that never resolves
+    await workerManager.destroy({ force: true });
+  });
+  test('start with 1 worker core', async () => {
     const workerManager = await WorkerManager.createWorkerManager<WorkerModule>(
       {
         workerFactory: () => spawn(new Worker('../src/worker')),

tests/utils.ts

@@ -0,0 +1,5 @@
+async function sleep(ms: number) {
+  return await new Promise((r) => setTimeout(r, ms));
+}
+
+export { sleep };