build: bump volta pnpm version

[poolifier.git] / tests / pools / utils.test.mjs

diff --git a/tests/pools/utils.test.mjs b/tests/pools/utils.test.mjs
index 5feb6596296914252a94231e5de19132968a832f..c6cc06d31487f2b492850203fb64ceda79d2ae87 100644 (file)
--- a/tests/pools/utils.test.mjs
+++ b/tests/pools/utils.test.mjs
@@ -1,17 +1,103 @@
+import cluster, { Worker as ClusterWorker } from 'node:cluster'
 import { Worker as ThreadWorker } from 'node:worker_threads'
-import { Worker as ClusterWorker } from 'node:cluster'
+
 import { expect } from 'expect'
+
 import {
   CircularArray,
   DEFAULT_CIRCULAR_ARRAY_SIZE
-} from '../../lib/circular-array.js'
+} from '../../lib/circular-array.cjs'
 import {
+  FixedClusterPool,
+  FixedThreadPool,
+  WorkerTypes
+} from '../../lib/index.cjs'
+import {
+  buildWorkerChoiceStrategyOptions,
   createWorker,
+  DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS,
+  getDefaultTasksQueueOptions,
+  getWorkerChoiceStrategyRetries,
+  getWorkerId,
+  getWorkerType,
   updateMeasurementStatistics
-} from '../../lib/pools/utils.js'
-import { WorkerTypes } from '../../lib/index.js'
+} from '../../lib/pools/utils.cjs'
 
 describe('Pool utils test suite', () => {
+  it('Verify DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS values', () => {
+    expect(DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS).toStrictEqual({
+      aggregate: false,
+      average: false,
+      median: false
+    })
+  })
+
+  it('Verify getDefaultTasksQueueOptions() behavior', () => {
+    const poolMaxSize = 4
+    expect(getDefaultTasksQueueOptions(poolMaxSize)).toStrictEqual({
+      concurrency: 1,
+      size: Math.pow(poolMaxSize, 2),
+      taskStealing: true,
+      tasksStealingOnBackPressure: true,
+      tasksFinishedTimeout: 2000
+    })
+  })
+
+  it('Verify getWorkerChoiceStrategyRetries() behavior', async () => {
+    const numberOfThreads = 4
+    const pool = new FixedThreadPool(
+      numberOfThreads,
+      './tests/worker-files/thread/testWorker.mjs'
+    )
+    expect(getWorkerChoiceStrategyRetries(pool)).toBe(pool.info.maxSize * 2)
+    const workerChoiceStrategyOptions = {
+      runTime: { median: true },
+      waitTime: { median: true },
+      elu: { median: true },
+      weights: {
+        0: 100,
+        1: 100
+      }
+    }
+    expect(
+      getWorkerChoiceStrategyRetries(pool, workerChoiceStrategyOptions)
+    ).toBe(
+      pool.info.maxSize +
+        Object.keys(workerChoiceStrategyOptions.weights).length
+    )
+    await pool.destroy()
+  })
+
+  it('Verify buildWorkerChoiceStrategyOptions() behavior', async () => {
+    const numberOfWorkers = 4
+    const pool = new FixedClusterPool(
+      numberOfWorkers,
+      './tests/worker-files/cluster/testWorker.cjs'
+    )
+    expect(buildWorkerChoiceStrategyOptions(pool)).toStrictEqual({
+      runTime: { median: false },
+      waitTime: { median: false },
+      elu: { median: false },
+      weights: expect.objectContaining({
+        0: expect.any(Number),
+        [pool.info.maxSize - 1]: expect.any(Number)
+      })
+    })
+    const workerChoiceStrategyOptions = {
+      runTime: { median: true },
+      waitTime: { median: true },
+      elu: { median: true },
+      weights: {
+        0: 100,
+        1: 100
+      }
+    }
+    expect(
+      buildWorkerChoiceStrategyOptions(pool, workerChoiceStrategyOptions)
+    ).toStrictEqual(workerChoiceStrategyOptions)
+    await pool.destroy()
+  })
+
   it('Verify updateMeasurementStatistics() behavior', () => {
     const measurementStatistics = {
       history: new CircularArray()
@@ -103,14 +189,34 @@ describe('Pool utils test suite', () => {
     expect(
       createWorker(
         WorkerTypes.thread,
-        './tests/worker-files/thread/testWorker.mjs'
+        './tests/worker-files/thread/testWorker.mjs',
+        {}
       )
     ).toBeInstanceOf(ThreadWorker)
     expect(
       createWorker(
         WorkerTypes.cluster,
-        './tests/worker-files/cluster/testWorker.mjs'
+        './tests/worker-files/cluster/testWorker.mjs',
+        {}
       )
     ).toBeInstanceOf(ClusterWorker)
   })
+
+  it('Verify getWorkerType() behavior', () => {
+    expect(
+      getWorkerType(
+        new ThreadWorker('./tests/worker-files/thread/testWorker.mjs')
+      )
+    ).toBe(WorkerTypes.thread)
+    expect(getWorkerType(cluster.fork())).toBe(WorkerTypes.cluster)
+  })
+
+  it('Verify getWorkerId() behavior', () => {
+    const threadWorker = new ThreadWorker(
+      './tests/worker-files/thread/testWorker.mjs'
+    )
+    const clusterWorker = cluster.fork()
+    expect(getWorkerId(threadWorker)).toBe(threadWorker.threadId)
+    expect(getWorkerId(clusterWorker)).toBe(clusterWorker.id)
+  })
 })