tests/pools/utils.test.mjs

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