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