build(deps): bump poolifier
[poolifier.git] / tests / utils.test.mjs
CommitLineData
a074ffee
JB
1import { Worker } from 'node:worker_threads'
2import cluster from 'node:cluster'
3import os from 'node:os'
4import { randomInt } from 'node:crypto'
5import { expect } from 'expect'
6import {
9274aa14
JB
7 DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS,
8 DEFAULT_TASK_NAME,
9 DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS,
10 EMPTY_FUNCTION,
afe0d5bf 11 availableParallelism,
dc021bcc 12 average,
98446b39 13 exponentialDelay,
9fe8fd69 14 getWorkerId,
a074ffee 15 getWorkerType,
78ac1a90 16 isAsyncFunction,
59317253 17 isKillBehavior,
afe0d5bf 18 isPlainObject,
90d6701c 19 max,
afe0d5bf 20 median,
90d6701c 21 min,
a91f7b35 22 round,
970b38d6 23 secureRandom,
bfc75cca 24 sleep
a074ffee
JB
25} from '../lib/utils.js'
26import { KillBehaviors, WorkerTypes } from '../lib/index.js'
aba955e1
JB
27
28describe('Utils test suite', () => {
9274aa14
JB
29 it('Verify DEFAULT_TASK_NAME value', () => {
30 expect(DEFAULT_TASK_NAME).toBe('default')
31 })
32
33 it('Verify EMPTY_FUNCTION value', () => {
34 expect(EMPTY_FUNCTION).toStrictEqual(expect.any(Function))
35 })
36
37 it('Verify DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS values', () => {
38 expect(DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS).toStrictEqual({
39 retries: 6,
40 runTime: { median: false },
41 waitTime: { median: false },
42 elu: { median: false }
43 })
44 })
45
46 it('Verify DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS values', () => {
47 expect(DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS).toStrictEqual({
48 aggregate: false,
49 average: false,
50 median: false
51 })
52 })
53
afe0d5bf 54 it('Verify availableParallelism() behavior', () => {
9fe8fd69
JB
55 const parallelism = availableParallelism()
56 expect(typeof parallelism === 'number').toBe(true)
37e31fac 57 expect(Number.isSafeInteger(parallelism)).toBe(true)
562a4037
JB
58 let expectedParallelism = 1
59 try {
60 expectedParallelism = os.availableParallelism()
61 } catch {
62 expectedParallelism = os.cpus().length
63 }
64 expect(parallelism).toBe(expectedParallelism)
9fe8fd69
JB
65 })
66
67 it('Verify getWorkerType() behavior', () => {
68 expect(
b2fd3f4a 69 getWorkerType(new Worker('./tests/worker-files/thread/testWorker.mjs'))
9fe8fd69
JB
70 ).toBe(WorkerTypes.thread)
71 expect(getWorkerType(cluster.fork())).toBe(WorkerTypes.cluster)
72 })
73
74 it('Verify getWorkerId() behavior', () => {
b2fd3f4a
JB
75 const threadWorker = new Worker(
76 './tests/worker-files/thread/testWorker.mjs'
77 )
9fe8fd69
JB
78 const clusterWorker = cluster.fork()
79 expect(getWorkerId(threadWorker)).toBe(threadWorker.threadId)
80 expect(getWorkerId(clusterWorker)).toBe(clusterWorker.id)
afe0d5bf
JB
81 })
82
bb9423b7 83 it('Verify sleep() behavior', async () => {
65deb7f0 84 const start = performance.now()
98446b39 85 await sleep(1000)
6543999f 86 const elapsed = performance.now() - start
4be58f3c 87 expect(elapsed).toBeGreaterThanOrEqual(999)
98446b39
JB
88 })
89
90 it('Verify exponentialDelay() behavior', () => {
1f0766e7
JB
91 const delay = exponentialDelay(randomInt(1000))
92 expect(typeof delay === 'number').toBe(true)
93 expect(delay).toBeGreaterThanOrEqual(Number.MIN_VALUE)
94 expect(delay).toBeLessThanOrEqual(Number.MAX_VALUE)
98446b39
JB
95 })
96
dc021bcc
JB
97 it('Verify average() computation', () => {
98 expect(average([])).toBe(0)
99 expect(average([0.08])).toBe(0.08)
100 expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(
101 3.1642857142857146
102 )
103 expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(
104 2.8533333333333335
105 )
106 })
107
bb615bd0 108 it('Verify median() computation', () => {
4a45e8d2 109 expect(median([])).toBe(0)
76845835
JB
110 expect(median([0.08])).toBe(0.08)
111 expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(3.05)
112 expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(2.535)
aba955e1
JB
113 })
114
afe0d5bf
JB
115 it('Verify round() behavior', () => {
116 expect(round(0)).toBe(0)
117 expect(round(0.5, 0)).toBe(1)
118 expect(round(0.5)).toBe(0.5)
119 expect(round(-0.5, 0)).toBe(-1)
120 expect(round(-0.5)).toBe(-0.5)
121 expect(round(1.005)).toBe(1.01)
122 expect(round(2.175)).toBe(2.18)
123 expect(round(5.015)).toBe(5.02)
124 expect(round(-1.005)).toBe(-1.01)
125 expect(round(-2.175)).toBe(-2.18)
126 expect(round(-5.015)).toBe(-5.02)
127 })
128
aba955e1
JB
129 it('Verify isPlainObject() behavior', () => {
130 expect(isPlainObject(null)).toBe(false)
131 expect(isPlainObject(undefined)).toBe(false)
132 expect(isPlainObject(true)).toBe(false)
133 expect(isPlainObject(false)).toBe(false)
134 expect(isPlainObject(0)).toBe(false)
135 expect(isPlainObject('')).toBe(false)
136 expect(isPlainObject([])).toBe(false)
137 expect(isPlainObject(() => {})).toBe(false)
138 expect(isPlainObject(new Date())).toBe(false)
139 expect(isPlainObject(new RegExp())).toBe(false)
140 expect(isPlainObject(new Error())).toBe(false)
141 expect(isPlainObject(new Map())).toBe(false)
142 expect(isPlainObject(new Set())).toBe(false)
143 expect(isPlainObject(new WeakMap())).toBe(false)
144 expect(isPlainObject(new WeakSet())).toBe(false)
145 expect(isPlainObject(new Int8Array())).toBe(false)
146 expect(isPlainObject(new Uint8Array())).toBe(false)
147 expect(isPlainObject(new Uint8ClampedArray())).toBe(false)
148 expect(isPlainObject(new Int16Array())).toBe(false)
149 expect(isPlainObject(new Uint16Array())).toBe(false)
150 expect(isPlainObject(new Int32Array())).toBe(false)
151 expect(isPlainObject(new Uint32Array())).toBe(false)
152 expect(isPlainObject(new Float32Array())).toBe(false)
153 expect(isPlainObject(new Float64Array())).toBe(false)
154 expect(isPlainObject(new BigInt64Array())).toBe(false)
155 expect(isPlainObject(new BigUint64Array())).toBe(false)
156 expect(isPlainObject(new Promise(() => {}))).toBe(false)
157 expect(isPlainObject(new WeakRef({}))).toBe(false)
158 expect(isPlainObject(new FinalizationRegistry(() => {}))).toBe(false)
159 expect(isPlainObject(new ArrayBuffer())).toBe(false)
160 expect(isPlainObject(new SharedArrayBuffer())).toBe(false)
161 expect(isPlainObject(new DataView(new ArrayBuffer()))).toBe(false)
162 expect(isPlainObject({})).toBe(true)
163 expect(isPlainObject({ a: 1 })).toBe(true)
164 })
47aacbaa
JB
165
166 it('Verify isKillBehavior() behavior', () => {
167 expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.SOFT)).toBe(true)
168 expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.HARD)).toBe(false)
169 expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.HARD)).toBe(true)
170 expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.SOFT)).toBe(false)
171 expect(isKillBehavior(KillBehaviors.SOFT)).toBe(false)
172 expect(isKillBehavior(KillBehaviors.HARD)).toBe(false)
173 expect(isKillBehavior(KillBehaviors.HARD, null)).toBe(false)
78ac1a90 174 expect(isKillBehavior(KillBehaviors.HARD, undefined)).toBe(false)
47aacbaa
JB
175 expect(isKillBehavior(KillBehaviors.SOFT, 'unknown')).toBe(false)
176 })
78ac1a90
JB
177
178 it('Verify isAsyncFunction() behavior', () => {
179 expect(isAsyncFunction(null)).toBe(false)
180 expect(isAsyncFunction(undefined)).toBe(false)
181 expect(isAsyncFunction(true)).toBe(false)
182 expect(isAsyncFunction(false)).toBe(false)
183 expect(isAsyncFunction(0)).toBe(false)
184 expect(isAsyncFunction('')).toBe(false)
185 expect(isAsyncFunction([])).toBe(false)
186 expect(isAsyncFunction(new Date())).toBe(false)
187 expect(isAsyncFunction(new RegExp())).toBe(false)
188 expect(isAsyncFunction(new Error())).toBe(false)
189 expect(isAsyncFunction(new Map())).toBe(false)
190 expect(isAsyncFunction(new Set())).toBe(false)
191 expect(isAsyncFunction(new WeakMap())).toBe(false)
192 expect(isAsyncFunction(new WeakSet())).toBe(false)
193 expect(isAsyncFunction(new Int8Array())).toBe(false)
194 expect(isAsyncFunction(new Uint8Array())).toBe(false)
195 expect(isAsyncFunction(new Uint8ClampedArray())).toBe(false)
196 expect(isAsyncFunction(new Int16Array())).toBe(false)
197 expect(isAsyncFunction(new Uint16Array())).toBe(false)
198 expect(isAsyncFunction(new Int32Array())).toBe(false)
199 expect(isAsyncFunction(new Uint32Array())).toBe(false)
200 expect(isAsyncFunction(new Float32Array())).toBe(false)
201 expect(isAsyncFunction(new Float64Array())).toBe(false)
202 expect(isAsyncFunction(new BigInt64Array())).toBe(false)
203 expect(isAsyncFunction(new BigUint64Array())).toBe(false)
204 expect(isAsyncFunction(new Promise(() => {}))).toBe(false)
205 expect(isAsyncFunction(new WeakRef({}))).toBe(false)
206 expect(isAsyncFunction(new FinalizationRegistry(() => {}))).toBe(false)
207 expect(isAsyncFunction(new ArrayBuffer())).toBe(false)
208 expect(isAsyncFunction(new SharedArrayBuffer())).toBe(false)
209 expect(isAsyncFunction(new DataView(new ArrayBuffer()))).toBe(false)
210 expect(isAsyncFunction({})).toBe(false)
211 expect(isAsyncFunction({ a: 1 })).toBe(false)
212 expect(isAsyncFunction(() => {})).toBe(false)
213 expect(isAsyncFunction(function () {})).toBe(false)
214 expect(isAsyncFunction(function named () {})).toBe(false)
215 expect(isAsyncFunction(async () => {})).toBe(true)
216 expect(isAsyncFunction(async function () {})).toBe(true)
217 expect(isAsyncFunction(async function named () {})).toBe(true)
218 })
a91f7b35 219
970b38d6
JB
220 it('Verify secureRandom() behavior', () => {
221 const randomNumber = secureRandom()
222 expect(typeof randomNumber === 'number').toBe(true)
223 expect(randomNumber).toBeGreaterThanOrEqual(0)
224 expect(randomNumber).toBeLessThan(1)
225 })
90d6701c
JB
226
227 it('Verify min() behavior', () => {
625449e0 228 expect(min()).toBe(Infinity)
90d6701c
JB
229 expect(min(1, 2)).toBe(1)
230 expect(min(2, 1)).toBe(1)
231 expect(min(1, 1)).toBe(1)
232 })
233
234 it('Verify max() behavior', () => {
625449e0 235 expect(max()).toBe(-Infinity)
90d6701c
JB
236 expect(max(1, 2)).toBe(2)
237 expect(max(2, 1)).toBe(2)
238 expect(max(1, 1)).toBe(1)
239 })
aba955e1 240})