repositories / poolifier.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #2004 from poolifier/combined-prs-branch
[poolifier.git] / tests / utils.test.mjs
CommitLineData
a074ffee
JB		 1import os from 'node:os'
2import { randomInt } from 'node:crypto'
3import { expect } from 'expect'
4import {
9274aa14 5 DEFAULT_TASK_NAME,
9274aa14 6 EMPTY_FUNCTION,
afe0d5bf 7 availableParallelism,
dc021bcc 8 average,
98446b39 9 exponentialDelay,
78ac1a90 10 isAsyncFunction,
59317253 11 isKillBehavior,
afe0d5bf 12 isPlainObject,
90d6701c 13 max,
afe0d5bf 14 median,
90d6701c 15 min,
55082af9 16 // once,
a91f7b35 17 round,
970b38d6 18 secureRandom,
bfc75cca 19 sleep
d35e5717 20} from '../lib/utils.cjs'
e9ed6eee 21import { KillBehaviors } from '../lib/index.cjs'
aba955e1
JB		 22
23describe('Utils test suite', () => {
9274aa14
JB		 24 it('Verify DEFAULT_TASK_NAME value', () => {
25 expect(DEFAULT_TASK_NAME).toBe('default')
26 })
27
28 it('Verify EMPTY_FUNCTION value', () => {
29 expect(EMPTY_FUNCTION).toStrictEqual(expect.any(Function))
30 })
31
afe0d5bf 32 it('Verify availableParallelism() behavior', () => {
9fe8fd69
JB		 33 const parallelism = availableParallelism()
34 expect(typeof parallelism === 'number').toBe(true)
37e31fac 35 expect(Number.isSafeInteger(parallelism)).toBe(true)
562a4037
JB		 36 let expectedParallelism = 1
37 try {
38 expectedParallelism = os.availableParallelism()
39 } catch {
40 expectedParallelism = os.cpus().length
41 }
42 expect(parallelism).toBe(expectedParallelism)
9fe8fd69
JB		 43 })
44
bb9423b7 45 it('Verify sleep() behavior', async () => {
65deb7f0 46 const start = performance.now()
b91134ce
JB		 47 const sleepMs = 1000
48 await sleep(sleepMs)
6543999f 49 const elapsed = performance.now() - start
b91134ce 50 expect(elapsed).toBeGreaterThanOrEqual(sleepMs - 1)
98446b39
JB		 51 })
52
53 it('Verify exponentialDelay() behavior', () => {
1f0766e7
JB		 54 const delay = exponentialDelay(randomInt(1000))
55 expect(typeof delay === 'number').toBe(true)
56 expect(delay).toBeGreaterThanOrEqual(Number.MIN_VALUE)
57 expect(delay).toBeLessThanOrEqual(Number.MAX_VALUE)
98446b39
JB		 58 })
59
dc021bcc
JB		 60 it('Verify average() computation', () => {
61 expect(average([])).toBe(0)
62 expect(average([0.08])).toBe(0.08)
63 expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(
64 3.1642857142857146
65 )
66 expect(average([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(
67 2.8533333333333335
68 )
69 })
70
bb615bd0 71 it('Verify median() computation', () => {
4a45e8d2 72 expect(median([])).toBe(0)
76845835
JB		 73 expect(median([0.08])).toBe(0.08)
74 expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(3.05)
75 expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(2.535)
aba955e1
JB		 76 })
77
afe0d5bf
JB		 78 it('Verify round() behavior', () => {
79 expect(round(0)).toBe(0)
80 expect(round(0.5, 0)).toBe(1)
81 expect(round(0.5)).toBe(0.5)
82 expect(round(-0.5, 0)).toBe(-1)
83 expect(round(-0.5)).toBe(-0.5)
84 expect(round(1.005)).toBe(1.01)
85 expect(round(2.175)).toBe(2.18)
86 expect(round(5.015)).toBe(5.02)
87 expect(round(-1.005)).toBe(-1.01)
88 expect(round(-2.175)).toBe(-2.18)
89 expect(round(-5.015)).toBe(-5.02)
90 })
91
aba955e1
JB		 92 it('Verify isPlainObject() behavior', () => {
93 expect(isPlainObject(null)).toBe(false)
94 expect(isPlainObject(undefined)).toBe(false)
95 expect(isPlainObject(true)).toBe(false)
96 expect(isPlainObject(false)).toBe(false)
97 expect(isPlainObject(0)).toBe(false)
98 expect(isPlainObject('')).toBe(false)
99 expect(isPlainObject([])).toBe(false)
100 expect(isPlainObject(() => {})).toBe(false)
101 expect(isPlainObject(new Date())).toBe(false)
102 expect(isPlainObject(new RegExp())).toBe(false)
103 expect(isPlainObject(new Error())).toBe(false)
104 expect(isPlainObject(new Map())).toBe(false)
105 expect(isPlainObject(new Set())).toBe(false)
106 expect(isPlainObject(new WeakMap())).toBe(false)
107 expect(isPlainObject(new WeakSet())).toBe(false)
108 expect(isPlainObject(new Int8Array())).toBe(false)
109 expect(isPlainObject(new Uint8Array())).toBe(false)
110 expect(isPlainObject(new Uint8ClampedArray())).toBe(false)
111 expect(isPlainObject(new Int16Array())).toBe(false)
112 expect(isPlainObject(new Uint16Array())).toBe(false)
113 expect(isPlainObject(new Int32Array())).toBe(false)
114 expect(isPlainObject(new Uint32Array())).toBe(false)
115 expect(isPlainObject(new Float32Array())).toBe(false)
116 expect(isPlainObject(new Float64Array())).toBe(false)
117 expect(isPlainObject(new BigInt64Array())).toBe(false)
118 expect(isPlainObject(new BigUint64Array())).toBe(false)
119 expect(isPlainObject(new Promise(() => {}))).toBe(false)
120 expect(isPlainObject(new WeakRef({}))).toBe(false)
121 expect(isPlainObject(new FinalizationRegistry(() => {}))).toBe(false)
122 expect(isPlainObject(new ArrayBuffer())).toBe(false)
123 expect(isPlainObject(new SharedArrayBuffer())).toBe(false)
124 expect(isPlainObject(new DataView(new ArrayBuffer()))).toBe(false)
125 expect(isPlainObject({})).toBe(true)
126 expect(isPlainObject({ a: 1 })).toBe(true)
127 })
47aacbaa
JB		 128
129 it('Verify isKillBehavior() behavior', () => {
130 expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.SOFT)).toBe(true)
131 expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.HARD)).toBe(false)
132 expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.HARD)).toBe(true)
133 expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.SOFT)).toBe(false)
134 expect(isKillBehavior(KillBehaviors.SOFT)).toBe(false)
135 expect(isKillBehavior(KillBehaviors.HARD)).toBe(false)
136 expect(isKillBehavior(KillBehaviors.HARD, null)).toBe(false)
78ac1a90 137 expect(isKillBehavior(KillBehaviors.HARD, undefined)).toBe(false)
47aacbaa
JB		 138 expect(isKillBehavior(KillBehaviors.SOFT, 'unknown')).toBe(false)
139 })
78ac1a90
JB		 140
141 it('Verify isAsyncFunction() behavior', () => {
142 expect(isAsyncFunction(null)).toBe(false)
143 expect(isAsyncFunction(undefined)).toBe(false)
144 expect(isAsyncFunction(true)).toBe(false)
145 expect(isAsyncFunction(false)).toBe(false)
146 expect(isAsyncFunction(0)).toBe(false)
147 expect(isAsyncFunction('')).toBe(false)
148 expect(isAsyncFunction([])).toBe(false)
149 expect(isAsyncFunction(new Date())).toBe(false)
f903b9c3
JB		 150 // eslint-disable-next-line prefer-regex-literals
151 expect(isAsyncFunction(new RegExp('[a-z]', 'i'))).toBe(false)
78ac1a90
JB		 152 expect(isAsyncFunction(new Error())).toBe(false)
153 expect(isAsyncFunction(new Map())).toBe(false)
154 expect(isAsyncFunction(new Set())).toBe(false)
155 expect(isAsyncFunction(new WeakMap())).toBe(false)
156 expect(isAsyncFunction(new WeakSet())).toBe(false)
157 expect(isAsyncFunction(new Int8Array())).toBe(false)
158 expect(isAsyncFunction(new Uint8Array())).toBe(false)
159 expect(isAsyncFunction(new Uint8ClampedArray())).toBe(false)
160 expect(isAsyncFunction(new Int16Array())).toBe(false)
161 expect(isAsyncFunction(new Uint16Array())).toBe(false)
162 expect(isAsyncFunction(new Int32Array())).toBe(false)
163 expect(isAsyncFunction(new Uint32Array())).toBe(false)
164 expect(isAsyncFunction(new Float32Array())).toBe(false)
165 expect(isAsyncFunction(new Float64Array())).toBe(false)
166 expect(isAsyncFunction(new BigInt64Array())).toBe(false)
167 expect(isAsyncFunction(new BigUint64Array())).toBe(false)
168 expect(isAsyncFunction(new Promise(() => {}))).toBe(false)
169 expect(isAsyncFunction(new WeakRef({}))).toBe(false)
170 expect(isAsyncFunction(new FinalizationRegistry(() => {}))).toBe(false)
f903b9c3
JB		 171 expect(isAsyncFunction(new ArrayBuffer(16))).toBe(false)
172 expect(isAsyncFunction(new SharedArrayBuffer(16))).toBe(false)
173 expect(isAsyncFunction(new DataView(new ArrayBuffer(16)))).toBe(false)
78ac1a90
JB		 174 expect(isAsyncFunction({})).toBe(false)
175 expect(isAsyncFunction({ a: 1 })).toBe(false)
176 expect(isAsyncFunction(() => {})).toBe(false)
177 expect(isAsyncFunction(function () {})).toBe(false)
178 expect(isAsyncFunction(function named () {})).toBe(false)
179 expect(isAsyncFunction(async () => {})).toBe(true)
180 expect(isAsyncFunction(async function () {})).toBe(true)
181 expect(isAsyncFunction(async function named () {})).toBe(true)
f903b9c3
JB		 182 class TestClass {
183 testSync () {}
184 async testAsync () {}
185 testArrowSync = () => {}
186 testArrowAsync = async () => {}
187 static testStaticSync () {}
188 static async testStaticAsync () {}
189 }
190 const testClass = new TestClass()
191 expect(isAsyncFunction(testClass.testSync)).toBe(false)
192 expect(isAsyncFunction(testClass.testAsync)).toBe(true)
193 expect(isAsyncFunction(testClass.testArrowSync)).toBe(false)
194 expect(isAsyncFunction(testClass.testArrowAsync)).toBe(true)
195 expect(isAsyncFunction(TestClass.testStaticSync)).toBe(false)
196 expect(isAsyncFunction(TestClass.testStaticAsync)).toBe(true)
78ac1a90 197 })
a91f7b35 198
970b38d6
JB		 199 it('Verify secureRandom() behavior', () => {
200 const randomNumber = secureRandom()
201 expect(typeof randomNumber === 'number').toBe(true)
202 expect(randomNumber).toBeGreaterThanOrEqual(0)
203 expect(randomNumber).toBeLessThan(1)
204 })
90d6701c
JB		 205
206 it('Verify min() behavior', () => {
625449e0 207 expect(min()).toBe(Infinity)
90d6701c
JB		 208 expect(min(1, 2)).toBe(1)
209 expect(min(2, 1)).toBe(1)
210 expect(min(1, 1)).toBe(1)
211 })
212
213 it('Verify max() behavior', () => {
625449e0 214 expect(max()).toBe(-Infinity)
90d6701c
JB		 215 expect(max(1, 2)).toBe(2)
216 expect(max(2, 1)).toBe(2)
217 expect(max(1, 1)).toBe(1)
218 })
d91689fd 219
bf44f757 220 // it('Verify once() behavior', () => {
55082af9
JB		 221 // let called = 0
222 // const fn = () => ++called
223 // const onceFn = once(fn, this)
224 // const result1 = onceFn()
225 // expect(called).toBe(1)
226 // expect(result1).toBe(1)
227 // const result2 = onceFn()
228 // expect(called).toBe(1)
229 // expect(result2).toBe(1)
230 // const result3 = onceFn()
231 // expect(called).toBe(1)
232 // expect(result3).toBe(1)
233 // })
aba955e1 234})
Fast and small Node.js thread pool implementation mirror - https://github.com/poolifier/poolifier