test: simplify (piscinajs#819)

Author: AugustinMauroy

scripts/run-tests.js

@@ -46,11 +46,12 @@ const args = [
   ...testFiles
 ];
 
+
 let result;
 if (isCoverage) {
   result = spawnSync('c8', ['--reporter=lcov', 'node', ...args], { stdio: 'inherit' });
 } else {
-  result = spawnSync('c8', ['node', ...args], { stdio: 'inherit' });
+  result = spawnSync('node', [...args], { stdio: 'inherit' });
 }
 
 process.exit(result.status);

test/abort-task.test.ts

@@ -1,43 +1,43 @@
-import { EventEmitter } from 'events';
-import Piscina from '..';
 import { test } from 'node:test';
-import type { TestContext } from 'node:test';
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import Piscina from '..';
 import { resolve } from 'path';
 
 const TIMEOUT_MAX = 2 ** 31 - 1;
 
-test('tasks can be aborted through AbortController while running', async (t: TestContext) => {
+test('tasks can be aborted through AbortController while running', () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/notify-then-sleep.ts')
   });
 
   const buf = new Int32Array(new SharedArrayBuffer(4));
   const abortController = new AbortController();
-  t.assert.rejects(pool.run(buf, { signal: abortController.signal }),
+  assert.rejects(pool.run(buf, { signal: abortController.signal }),
     /The task has been aborted/);
 
   Atomics.wait(buf, 0, 0);
-  t.assert.strictEqual(Atomics.load(buf, 0), 1);
+  assert.strictEqual(Atomics.load(buf, 0), 1);
 
   abortController.abort();
 });
 
-test('tasks can be aborted through EventEmitter while running', async (t: TestContext) => {
+test('tasks can be aborted through EventEmitter while running', () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/notify-then-sleep.ts')
   });
 
   const buf = new Int32Array(new SharedArrayBuffer(4));
   const ee = new EventEmitter();
-  t.assert.rejects(pool.run(buf, { signal: ee }), /The task has been aborted/);
+  assert.rejects(pool.run(buf, { signal: ee }), /The task has been aborted/);
 
   Atomics.wait(buf, 0, 0);
-  t.assert.strictEqual(Atomics.load(buf, 0), 1);
+  assert.strictEqual(Atomics.load(buf, 0), 1);
 
   ee.emit('abort');
 });
 
-test('tasks can be aborted through EventEmitter before running', async (t: TestContext) => {
+test('tasks can be aborted through EventEmitter before running', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/wait-for-notify.js'),
     maxThreads: 1
@@ -50,8 +50,8 @@ test('tasks can be aborted through EventEmitter before running', async (t: TestC
   const ee = new EventEmitter();
   const task1 = pool.run(bufs[0]);
   const abortable = pool.run(bufs[1], { signal: ee });
-  t.assert.strictEqual(pool.queueSize, 0); // Means it's running
-  t.assert.rejects(abortable, /The task has been aborted/);
+  assert.strictEqual(pool.queueSize, 0); // Means it's running
+  assert.rejects(abortable, /The task has been aborted/);
 
   ee.emit('abort');
 
@@ -61,7 +61,7 @@ test('tasks can be aborted through EventEmitter before running', async (t: TestC
   await task1;
 });
 
-test('abortable tasks will not share workers (abortable posted second)', async (t: TestContext) => {
+test('abortable tasks will not share workers (abortable posted second)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/wait-for-notify.ts'),
     maxThreads: 1,
@@ -74,8 +74,8 @@ test('abortable tasks will not share workers (abortable posted second)', async (
   ];
   const task1 = pool.run(bufs[0]);
   const ee = new EventEmitter();
-  t.assert.rejects(pool.run(bufs[1], { signal: ee }), /The task has been aborted/);
-  t.assert.strictEqual(pool.queueSize, 0);
+  assert.rejects(pool.run(bufs[1], { signal: ee }), /The task has been aborted/);
+  assert.strictEqual(pool.queueSize, 0);
 
   ee.emit('abort');
 
@@ -86,26 +86,26 @@ test('abortable tasks will not share workers (abortable posted second)', async (
 });
 
 // TODO: move to testing balancer
-test('abortable tasks will not share workers (abortable posted first)', async (t: TestContext) => {
+test('abortable tasks will not share workers (abortable posted first)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/eval.js'),
     maxThreads: 1,
     concurrentTasksPerWorker: 2
   });
 
   const ee = new EventEmitter();
-  t.assert.rejects(pool.run('while(true);', { signal: ee }), /The task has been aborted/);
+  assert.rejects(pool.run('while(true);', { signal: ee }), /The task has been aborted/);
   const task2 = pool.run('42');
-  t.assert.strictEqual(pool.queueSize, 1);
+  assert.strictEqual(pool.queueSize, 1);
 
   ee.emit('abort');
 
   // Wake up the thread handling the second task.
-  t.assert.strictEqual(await task2, 42);
+  assert.strictEqual(await task2, 42);
 });
 
 // TODO: move to testing balancer
-test('abortable tasks will not share workers (on worker available)', async (t: TestContext) => {
+test('abortable tasks will not share workers (on worker available)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/sleep.js'),
     maxThreads: 1,
@@ -123,12 +123,12 @@ test('abortable tasks will not share workers (on worker available)', async (t: T
     pool.run({ time: 100, a: 3 }, { signal: new EventEmitter() })
   ]);
 
-  t.assert.strictEqual(ret[0], 0);
-  t.assert.strictEqual(ret[1], 1);
-  t.assert.strictEqual(ret[2], 2);
+  assert.strictEqual(ret[0], 0);
+  assert.strictEqual(ret[1], 1);
+  assert.strictEqual(ret[2], 2);
 });
 
-test('abortable tasks will not share workers (destroy workers)', async (t: TestContext) => {
+test('abortable tasks will not share workers (destroy workers)', () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/sleep.js'),
     maxThreads: 1,
@@ -145,30 +145,30 @@ test('abortable tasks will not share workers (destroy workers)', async (t: TestC
     pool.destroy();
   });
 
-  t.assert.rejects(pool.run({ time: TIMEOUT_MAX, a: 2 }), /Terminating worker thread/);
-  t.assert.rejects(pool.run({ time: TIMEOUT_MAX, a: 3 }, { signal: new EventEmitter() }),
+  assert.rejects(pool.run({ time: TIMEOUT_MAX, a: 2 }), /Terminating worker thread/);
+  assert.rejects(pool.run({ time: TIMEOUT_MAX, a: 3 }, { signal: new EventEmitter() }),
     /Terminating worker thread/);
 });
 
-test('aborted AbortSignal rejects task immediately', async (t: TestContext) => {
+test('aborted AbortSignal rejects task immediately', () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/move.ts')
   });
 
   const controller = new AbortController();
   // Abort the controller early
   controller.abort();
-  t.assert.strictEqual(controller.signal.aborted, true);
+  assert.strictEqual(controller.signal.aborted, true);
 
   // The data won't be moved because the task will abort immediately.
   const data = new Uint8Array(new SharedArrayBuffer(4));
-  t.assert.rejects(pool.run(data, { signal: controller.signal, transferList: [data.buffer] }),
+  assert.rejects(pool.run(data, { signal: controller.signal, transferList: [data.buffer] }),
     /The task has been aborted/);
 
-  t.assert.strictEqual(data.length, 4);
+  assert.strictEqual(data.length, 4);
 });
 
-test('task with AbortSignal cleans up properly', async (t: TestContext) => {
+test('task with AbortSignal cleans up properly', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/eval.js')
   });
@@ -179,39 +179,39 @@ test('task with AbortSignal cleans up properly', async (t: TestContext) => {
 
   const { getEventListeners } = EventEmitter as any;
   if (typeof getEventListeners === 'function') {
-    t.assert.strictEqual(getEventListeners(ee, 'abort').length, 0);
+    assert.strictEqual(getEventListeners(ee, 'abort').length, 0);
   }
 
   const controller = new AbortController();
 
   await pool.run('1+1', { signal: controller.signal });
 });
 
-test('aborted AbortSignal rejects task immediately (with reason)', async (t: TestContext) => {
+test('aborted AbortSignal rejects task immediately (with reason)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/move.ts')
   });
   const customReason = new Error('custom reason');
 
   const controller = new AbortController();
   controller.abort(customReason);
-  t.assert.strictEqual(controller.signal.aborted, true);
-  t.assert.strictEqual(controller.signal.reason, customReason);
+  assert.strictEqual(controller.signal.aborted, true);
+  assert.strictEqual(controller.signal.reason, customReason);
 
   // The data won't be moved because the task will abort immediately.
   const data = new Uint8Array(new SharedArrayBuffer(4));
 
   try {
     await pool.run(data, { transferList: [data.buffer], signal: controller.signal });
   } catch (error) {
-    t.assert.strictEqual(error.message, 'The task has been aborted');
-    t.assert.strictEqual(error.cause, customReason);
+    assert.strictEqual(error.message, 'The task has been aborted');
+    assert.strictEqual(error.cause, customReason);
   }
 
-  t.assert.strictEqual(data.length, 4);
+  assert.strictEqual(data.length, 4);
 });
 
-test('tasks can be aborted through AbortController while running', async (t: TestContext) => {
+test('tasks can be aborted through AbortController while running', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/notify-then-sleep.ts')
   });
@@ -224,42 +224,42 @@ test('tasks can be aborted through AbortController while running', async (t: Tes
     const promise = pool.run(buf, { signal: abortController.signal });
 
     Atomics.wait(buf, 0, 0);
-    t.assert.strictEqual(Atomics.load(buf, 0), 1);
+    assert.strictEqual(Atomics.load(buf, 0), 1);
 
     abortController.abort(reason);
 
     await promise;
   } catch (error) {
-    t.assert.strictEqual(error.message, 'The task has been aborted');
-    t.assert.strictEqual(error.cause, reason);
+    assert.strictEqual(error.message, 'The task has been aborted');
+    assert.strictEqual(error.cause, reason);
   }
 });
 
-test('aborted AbortSignal rejects task immediately (with reason)', async (t: TestContext) => {
+test('aborted AbortSignal rejects task immediately (with reason)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/move.ts')
   });
   const customReason = new Error('custom reason');
 
   const controller = new AbortController();
   controller.abort(customReason);
-  t.assert.strictEqual(controller.signal.aborted, true);
-  t.assert.strictEqual(controller.signal.reason, customReason);
+  assert.strictEqual(controller.signal.aborted, true);
+  assert.strictEqual(controller.signal.reason, customReason);
 
   // The data won't be moved because the task will abort immediately.
   const data = new Uint8Array(new SharedArrayBuffer(4));
 
   try {
     await pool.run(data, { transferList: [data.buffer], signal: controller.signal });
   } catch (error) {
-    t.assert.strictEqual(error.message, 'The task has been aborted');
-    t.assert.strictEqual(error.cause, customReason);
+    assert.strictEqual(error.message, 'The task has been aborted');
+    assert.strictEqual(error.cause, customReason);
   }
 
-  t.assert.strictEqual(data.length, 4);
+  assert.strictEqual(data.length, 4);
 });
 
-test('tasks can be aborted through AbortController while running', async (t: TestContext) => {
+test('tasks can be aborted through AbortController while running', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/notify-then-sleep.ts')
   });
@@ -272,13 +272,13 @@ test('tasks can be aborted through AbortController while running', async (t: Tes
     const promise = pool.run(buf, { signal: abortController.signal });
 
     Atomics.wait(buf, 0, 0);
-    t.assert.strictEqual(Atomics.load(buf, 0), 1);
+    assert.strictEqual(Atomics.load(buf, 0), 1);
 
     abortController.abort(reason);
 
     await promise;
   } catch (error) {
-    t.assert.strictEqual(error.message, 'The task has been aborted');
-    t.assert.strictEqual(error.cause, reason);
+    assert.strictEqual(error.message, 'The task has been aborted');
+    assert.strictEqual(error.cause, reason);
   }
 });

test/async-context.test.ts

@@ -1,10 +1,11 @@
-import { createHook, executionAsyncId } from 'async_hooks';
-import Piscina from '..';
+import assert from 'node:assert/strict';
 import { test } from 'node:test';
-import type { TestContext } from 'node:test';
-import { resolve } from 'path';
+import { resolve } from 'node:path';
+import { createHook, executionAsyncId } from 'node:async_hooks';
+import Piscina from '..';
+
 
-test('postTask() calls the correct async hooks', async (t: TestContext) => {
+test('postTask() calls the correct async hooks', async () => {
   let taskId;
   let initCalls = 0;
   let beforeCalls = 0;
@@ -37,8 +38,8 @@ test('postTask() calls the correct async hooks', async (t: TestContext) => {
   await pool.run('42');
 
   hook.disable();
-  t.assert.strictEqual(initCalls, 1);
-  t.assert.strictEqual(beforeCalls, 1);
-  t.assert.strictEqual(afterCalls, 1);
-  t.assert.strictEqual(resolveCalls, 1);
+  assert.strictEqual(initCalls, 1);
+  assert.strictEqual(beforeCalls, 1);
+  assert.strictEqual(afterCalls, 1);
+  assert.strictEqual(resolveCalls, 1);
 });

test/atomics-optimization.test.ts

@@ -1,11 +1,9 @@
-import { resolve } from 'node:path';
-
+import assert from 'node:assert/strict';
 import { test } from 'node:test';
-import type { TestContext } from 'node:test';
-
+import { resolve } from 'node:path';
 import Piscina from '..';
 
-test('coverage test for Atomics optimization (sync mode)', async (t: TestContext) => {
+test('coverage test for Atomics optimization (sync mode)', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/notify-then-sleep-or.js'),
     minThreads: 2,
@@ -33,7 +31,7 @@ test('coverage test for Atomics optimization (sync mode)', async (t: TestContext
   // The check above could also be !== 2 but it's hard to get things right
   // sometimes and this gives us a nice assertion. Basically, at this point
   // exactly 2 tasks should be in Atomics.wait() state.
-  t.assert.strictEqual(popcount8(v), 2);
+  assert.strictEqual(popcount8(v), 2);
   // Wake both tasks up as simultaneously as possible. The other 2 tasks should
   // then start executing.
   Atomics.store(i32array, 0, 0);
@@ -53,7 +51,7 @@ test('coverage test for Atomics optimization (sync mode)', async (t: TestContext
 
   // Wake up the remaining 2 tasks in order to make sure that the test finishes.
   // Do the same consistency check beforehand as above.
-  t.assert.strictEqual(popcount8(v), 2);
+  assert.strictEqual(popcount8(v), 2);
   Atomics.store(i32array, 0, 0);
   Atomics.notify(i32array, 0, Infinity);
 
@@ -85,7 +83,7 @@ test('avoids unbounded recursion', async () => {
   await Promise.all(tasks);
 });
 
-test('enable async mode', async (t: TestContext) => {
+test('enable async mode', async () => {
   const pool = new Piscina({
     filename: resolve(__dirname, 'fixtures/eval-params.js'),
     minThreads: 1,
@@ -112,12 +110,10 @@ test('enable async mode', async (t: TestContext) => {
     shared: bufs
   });
 
-  t.plan(2);
-
   const atResult1 = Atomics.wait(bufs[0], 0, 0);
   const atResult2 = Atomics.wait(bufs[1], 0, 0);
   const atResult3 = Atomics.wait(bufs[2], 0, 0);
 
-  t.assert.deepStrictEqual([atResult1, atResult2, atResult3], ['ok', 'ok', 'ok']);
-  t.assert.strictEqual(await promise, true);
+  assert.deepStrictEqual([atResult1, atResult2, atResult3], ['ok', 'ok', 'ok']);
+  assert.strictEqual(await promise, true);
 });