repositories / poolifier.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
refactor: cleanup .gitignore
[poolifier.git] / tests / utils.test.mjs
... / ...
CommitLineData
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 {
7 DEFAULT_MEASUREMENT_STATISTICS_REQUIREMENTS,
8 DEFAULT_TASK_NAME,
9 DEFAULT_WORKER_CHOICE_STRATEGY_OPTIONS,
10 EMPTY_FUNCTION,
11 availableParallelism,
12 average,
13 exponentialDelay,
14 getWorkerId,
15 getWorkerType,
16 isAsyncFunction,
17 isKillBehavior,
18 isPlainObject,
19 max,
20 median,
21 min,
22 round,
23 secureRandom,
24 sleep
25} from '../lib/utils.js'
26import { KillBehaviors, WorkerTypes } from '../lib/index.js'
27
28describe('Utils test suite', () => {
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
54 it('Verify availableParallelism() behavior', () => {
55 const parallelism = availableParallelism()
56 expect(typeof parallelism === 'number').toBe(true)
57 expect(Number.isSafeInteger(parallelism)).toBe(true)
58 let expectedParallelism = 1
59 try {
60 expectedParallelism = os.availableParallelism()
61 } catch {
62 expectedParallelism = os.cpus().length
63 }
64 expect(parallelism).toBe(expectedParallelism)
65 })
66
67 it('Verify getWorkerType() behavior', () => {
68 expect(
69 getWorkerType(new Worker('./tests/worker-files/thread/testWorker.mjs'))
70 ).toBe(WorkerTypes.thread)
71 expect(getWorkerType(cluster.fork())).toBe(WorkerTypes.cluster)
72 })
73
74 it('Verify getWorkerId() behavior', () => {
75 const threadWorker = new Worker(
76 './tests/worker-files/thread/testWorker.mjs'
77 )
78 const clusterWorker = cluster.fork()
79 expect(getWorkerId(threadWorker)).toBe(threadWorker.threadId)
80 expect(getWorkerId(clusterWorker)).toBe(clusterWorker.id)
81 })
82
83 it('Verify sleep() behavior', async () => {
84 const start = performance.now()
85 await sleep(1000)
86 const elapsed = performance.now() - start
87 expect(elapsed).toBeGreaterThanOrEqual(999)
88 })
89
90 it('Verify exponentialDelay() behavior', () => {
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)
95 })
96
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
108 it('Verify median() computation', () => {
109 expect(median([])).toBe(0)
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)
113 })
114
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
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 })
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)
174 expect(isKillBehavior(KillBehaviors.HARD, undefined)).toBe(false)
175 expect(isKillBehavior(KillBehaviors.SOFT, 'unknown')).toBe(false)
176 })
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 })
219
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 })
226
227 it('Verify min() behavior', () => {
228 expect(min()).toBe(Infinity)
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', () => {
235 expect(max()).toBe(-Infinity)
236 expect(max(1, 2)).toBe(2)
237 expect(max(2, 1)).toBe(2)
238 expect(max(1, 1)).toBe(1)
239 })
240})
Fast and small Node.js thread pool implementation mirror - https://github.com/poolifier/poolifier