tests/pools/utils.test.mjs

   1 import cluster, { Worker as ClusterWorker } from 'node:cluster'
   2 import { Worker as ThreadWorker } from 'node:worker_threads'
   3
   4 import { expect } from 'expect'
   5
   6 import { CircularBuffer } from '../../lib/circular-buffer.cjs'
   7 import { WorkerTypes } from '../../lib/index.cjs'
   8 import {
   9   createWorker,
  10   DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS,
  11   getDefaultTasksQueueOptions,
  12   getWorkerId,
  13   getWorkerType,
  14   updateMeasurementStatistics
  15 } from '../../lib/pools/utils.cjs'
  16 import { MeasurementHistorySize } from '../../lib/pools/worker.cjs'
  17
  18 describe('Pool utils test suite', () => {
  19   it('Verify DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS values', () => {
  20     expect(DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS).toStrictEqual({
  21       aggregate: false,
  22       average: false,
  23       median: false
  24     })
  25   })
  26
  27   it('Verify getDefaultTasksQueueOptions() behavior', () => {
  28     const poolMaxSize = 4
  29     expect(getDefaultTasksQueueOptions(poolMaxSize)).toStrictEqual({
  30       concurrency: 1,
  31       size: Math.pow(poolMaxSize, 2),
  32       taskStealing: true,
  33       tasksStealingOnBackPressure: false,
  34       tasksFinishedTimeout: 2000
  35     })
  36   })
  37
  38   it('Verify updateMeasurementStatistics() behavior', () => {
  39     // const circularBuffer = new CircularBuffer(MeasurementHistorySize)
  40     const measurementStatistics = {
  41       history: new CircularBuffer(MeasurementHistorySize)
  42     }
  43     updateMeasurementStatistics(
  44       measurementStatistics,
  45       { aggregate: true, average: false, median: false },
  46       0.01
  47     )
  48     expect(measurementStatistics).toMatchObject({
  49       aggregate: 0.01,
  50       maximum: 0.01,
  51       minimum: 0.01
  52     })
  53     updateMeasurementStatistics(
  54       measurementStatistics,
  55       { aggregate: true, average: false, median: false },
  56       0.02
  57     )
  58     expect(measurementStatistics).toMatchObject({
  59       aggregate: 0.03,
  60       maximum: 0.02,
  61       minimum: 0.01
  62     })
  63     updateMeasurementStatistics(
  64       measurementStatistics,
  65       { aggregate: true, average: true, median: false },
  66       0.001
  67     )
  68     expect(measurementStatistics).toMatchObject({
  69       aggregate: 0.031,
  70       maximum: 0.02,
  71       minimum: 0.001,
  72       average: 0.0010000000474974513
  73     })
  74     updateMeasurementStatistics(
  75       measurementStatistics,
  76       { aggregate: true, average: true, median: false },
  77       0.003
  78     )
  79     expect(measurementStatistics).toMatchObject({
  80       aggregate: 0.034,
  81       maximum: 0.02,
  82       minimum: 0.001,
  83       average: 0.0020000000367872417
  84     })
  85     updateMeasurementStatistics(
  86       measurementStatistics,
  87       { aggregate: true, average: false, median: true },
  88       0.006
  89     )
  90     expect(measurementStatistics).toMatchObject({
  91       aggregate: 0.04,
  92       maximum: 0.02,
  93       minimum: 0.001,
  94       median: 0.003000000026077032
  95     })
  96     updateMeasurementStatistics(
  97       measurementStatistics,
  98       { aggregate: true, average: true, median: false },
  99       0.01
 100     )
 101     expect(measurementStatistics).toMatchObject({
 102       aggregate: 0.05,
 103       maximum: 0.02,
 104       minimum: 0.001,
 105       average: 0.004999999975552782
 106     })
 107   })
 108
 109   it('Verify createWorker() behavior', () => {
 110     expect(
 111       createWorker(
 112         WorkerTypes.thread,
 113         './tests/worker-files/thread/testWorker.mjs',
 114         {}
 115       )
 116     ).toBeInstanceOf(ThreadWorker)
 117     expect(
 118       createWorker(
 119         WorkerTypes.cluster,
 120         './tests/worker-files/cluster/testWorker.mjs',
 121         {}
 122       )
 123     ).toBeInstanceOf(ClusterWorker)
 124   })
 125
 126   it('Verify getWorkerType() behavior', () => {
 127     expect(
 128       getWorkerType(
 129         new ThreadWorker('./tests/worker-files/thread/testWorker.mjs')
 130       )
 131     ).toBe(WorkerTypes.thread)
 132     expect(getWorkerType(cluster.fork())).toBe(WorkerTypes.cluster)
 133   })
 134
 135   it('Verify getWorkerId() behavior', () => {
 136     const threadWorker = new ThreadWorker(
 137       './tests/worker-files/thread/testWorker.mjs'
 138     )
 139     const clusterWorker = cluster.fork()
 140     expect(getWorkerId(threadWorker)).toBe(threadWorker.threadId)
 141     expect(getWorkerId(clusterWorker)).toBe(clusterWorker.id)
 142   })
 143 })