init

node_modules/piscina/test/simple-test.test.ts

@@ -0,0 +1,236 @@
+import assert from 'node:assert';
+import { test } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+import { EventEmitter } from 'node:events';
+import Piscina from '..';
+import { version } from '../package.json';
+
+test('Piscina is exposed on export', () => {
+  assert.strictEqual(Piscina.version, version);
+});
+
+test('Piscina is exposed on itself', () => {
+  assert.strictEqual(Piscina.Piscina, Piscina);
+});
+
+test('Piscina.isWorkerThread has the correct value', () => {
+  assert.strictEqual(Piscina.isWorkerThread, false);
+});
+
+test('Piscina.isWorkerThread has the correct value (worker)', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-isworkerthread.ts')
+  });
+  const result = await worker.run(null);
+  assert.strictEqual(result, 'done');
+});
+
+test('Piscina.isWorkerThread has the correct value (worker) with named import', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-isworkerthread-named-import.ts')
+  });
+  const result = await worker.run(null);
+  assert.strictEqual(result, 'done');
+});
+
+test('Piscina.isWorkerThread has the correct value (worker) with named import', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-isworkerthread-named-import.ts')
+  });
+  const result = await worker.run(null);
+  assert.strictEqual(result, 'done');
+});
+
+test('Piscina instance is an EventEmitter', async () => {
+  const piscina = new Piscina();
+  assert.ok(piscina instanceof EventEmitter);
+});
+
+test('Piscina constructor options are correctly set', async () => {
+  const piscina = new Piscina({
+    minThreads: 10,
+    maxThreads: 20,
+    maxQueue: 30
+  });
+
+  assert.strictEqual(piscina.options.minThreads, 10);
+  assert.strictEqual(piscina.options.maxThreads, 20);
+  assert.strictEqual(piscina.options.maxQueue, 30);
+});
+
+test('trivial eval() handler works', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js')
+  });
+  const result = await worker.run('42');
+  assert.strictEqual(result, 42);
+});
+
+test('async eval() handler works', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js')
+  });
+  const result = await worker.run('Promise.resolve(42)');
+  assert.strictEqual(result, 42);
+});
+
+test('filename can be provided while posting', async () => {
+  const worker = new Piscina();
+  const result = await worker.run(
+    'Promise.resolve(42)',
+    { filename: resolve(__dirname, 'fixtures/eval.js') });
+  assert.strictEqual(result, 42);
+});
+
+test('filename can be null when initially provided', async () => {
+  const worker = new Piscina({ filename: null });
+  const result = await worker.run(
+    'Promise.resolve(42)',
+    { filename: resolve(__dirname, 'fixtures/eval.js') });
+  assert.strictEqual(result, 42);
+});
+
+test('filename must be provided while posting', () => {
+  const worker = new Piscina();
+  assert.rejects(worker.run('doesn’t matter'),
+    /filename must be provided to run\(\) or in options object/);
+});
+
+test('passing env to workers works', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js'),
+    env: { A: 'foo' }
+  });
+
+  const env = await pool.run('({...process.env})');
+  assert.deepStrictEqual(env, { A: 'foo' });
+});
+
+test('passing argv to workers works', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js'),
+    argv: ['a', 'b', 'c']
+  });
+
+  const env = await pool.run('process.argv.slice(2)');
+  assert.deepStrictEqual(env, ['a', 'b', 'c']);
+});
+
+test('passing execArgv to workers works', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js'),
+    execArgv: ['--no-warnings']
+  });
+
+  const env = await pool.run('process.execArgv');
+  assert.deepStrictEqual(env, ['--no-warnings']);
+});
+
+test('passing valid workerData works', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-workerdata.ts'),
+    workerData: 'ABC'
+  });
+  assert.strictEqual(Piscina.workerData, undefined);
+
+  await pool.run(null);
+});
+
+test('passing valid workerData works with named import', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-workerdata-named-import.ts'),
+    workerData: 'ABC'
+  });
+  assert.strictEqual(Piscina.workerData, undefined);
+
+  await pool.run(null);
+});
+
+test('passing valid workerData works with named import', async () => {
+  const pool = new Piscina({
+    filename: resolve(__dirname, 'fixtures/simple-workerdata-named-import.ts'),
+    workerData: 'ABC'
+  });
+  assert.strictEqual(Piscina.workerData, undefined);
+
+  await pool.run(null);
+});
+
+test('passing invalid workerData does not work', () => {
+  assert.throws(() => new Piscina(({
+    filename: resolve(__dirname, 'fixtures/simple-workerdata.ts'),
+    workerData: {
+      hello () {}
+    }
+  })), /could not be cloned./);
+});
+
+test('filename can be a file:// URL', async () => {
+  const worker = new Piscina({
+    filename: pathToFileURL(resolve(__dirname, 'fixtures/eval.js')).href
+  });
+  const result = await worker.run('42');
+  assert.strictEqual(result, 42);
+});
+
+test('filename can be a file:// URL to an ESM module', {}, async () => {
+  const worker = new Piscina({
+    filename: pathToFileURL(resolve(__dirname, 'fixtures/esm-export.mjs')).href
+  });
+  const result = await worker.run('42');
+  assert.strictEqual(result, 42);
+});
+
+test('duration and utilization calculations work', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js')
+  });
+
+  // Initial utilization is always 0
+  assert.strictEqual(worker.utilization, 0);
+
+  await Promise.all([
+    worker.run('42'),
+    worker.run('41'),
+    worker.run('40')
+  ]);
+
+  // utilization is going to be some non-deterministic value
+  // between 0 and 1. It should not be zero at this point
+  // because tasks have run, but it should also never be 1
+  assert.ok(worker.utilization > 0);
+  assert.ok(worker.utilization < 1);
+
+  // Duration must be non-zero.
+  assert.ok(worker.duration > 0);
+});
+
+test('run works also', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/eval.js')
+  });
+
+  await worker.run(42);
+});
+
+test('named tasks work', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/multiple.js')
+  });
+
+  assert.strictEqual(await worker.run({}, { name: 'a' }), 'a');
+  assert.strictEqual(await worker.run({}, { name: 'b' }), 'b');
+  assert.strictEqual(await worker.run({}), 'a');
+});
+
+test('named tasks work', async () => {
+  const worker = new Piscina({
+    filename: resolve(__dirname, 'fixtures/multiple.js'),
+    name: 'b'
+  });
+
+  assert.strictEqual(await worker.run({}, { name: 'a' }), 'a');
+  assert.strictEqual(await worker.run({}, { name: 'b' }), 'b');
+  assert.strictEqual(await worker.run({}), 'b');
+});