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 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       maximum: 0.02,
  70       minimum: 0.001,
  71       average: 0.0010000000474974513
  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       maximum: 0.02,
  81       minimum: 0.001,
  82       average: 0.0020000000367872417
  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       minimum: 0.001,
  93       median: 0.003000000026077032
  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       maximum: 0.02,
 103       minimum: 0.001,
 104       average: 0.004999999975552782
 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 })