1 import { describe
, it
} from
'node:test'
3 import { hoursToMilliseconds
, hoursToSeconds
} from
'date-fns'
4 import { expect
} from
'expect'
6 import { Constants
} from
'../../src/utils/Constants.js'
13 extractTimeSeriesValues
,
14 formatDurationMilliSeconds
,
15 formatDurationSeconds
,
38 } from
'../../src/utils/Utils.js'
40 await describe('Utils test suite', async () => {
41 await it('Verify generateUUID()/validateUUID()', () => {
42 const uuid
= generateUUID()
43 expect(uuid
).toBeDefined()
44 expect(uuid
.length
).toEqual(36)
45 expect(validateUUID(uuid
)).toBe(true)
46 expect(validateUUID('abcdef00-0000-4000-0000-000000000000')).toBe(true)
47 expect(validateUUID('')).toBe(false)
48 // Shall invalidate Nil UUID
49 expect(validateUUID('00000000-0000-0000-0000-000000000000')).toBe(false)
50 expect(validateUUID('987FBC9-4BED-3078-CF07A-9141BA07C9F3')).toBe(false)
53 await it('Verify sleep()', async () => {
54 const start
= performance
.now()
56 const stop
= performance
.now()
57 expect(stop
- start
).toBeGreaterThanOrEqual(1000)
60 await it('Verify formatDurationMilliSeconds()', () => {
61 expect(formatDurationMilliSeconds(0)).toBe('0 seconds')
62 expect(formatDurationMilliSeconds(900)).toBe('0 seconds')
63 expect(formatDurationMilliSeconds(1000)).toBe('1 second')
64 expect(formatDurationMilliSeconds(hoursToMilliseconds(4380))).toBe('182 days 12 hours')
67 await it('Verify formatDurationSeconds()', () => {
68 expect(formatDurationSeconds(0)).toBe('0 seconds')
69 expect(formatDurationSeconds(0.9)).toBe('0 seconds')
70 expect(formatDurationSeconds(1)).toBe('1 second')
71 expect(formatDurationSeconds(hoursToSeconds(4380))).toBe('182 days 12 hours')
74 await it('Verify isValidTime()', () => {
75 expect(isValidTime(undefined)).toBe(false)
76 expect(isValidTime(null)).toBe(false)
77 expect(isValidTime('')).toBe(false)
78 expect(isValidTime({})).toBe(false)
79 expect(isValidTime([])).toBe(false)
80 expect(isValidTime(new Map())).toBe(false)
81 expect(isValidTime(new Set())).toBe(false)
82 expect(isValidTime(new WeakMap())).toBe(false)
83 expect(isValidTime(new WeakSet())).toBe(false)
84 expect(isValidTime(-1)).toBe(true)
85 expect(isValidTime(0)).toBe(true)
86 expect(isValidTime(1)).toBe(true)
87 expect(isValidTime(-0.5)).toBe(true)
88 expect(isValidTime(0.5)).toBe(true)
89 expect(isValidTime(new Date())).toBe(true)
92 await it('Verify convertToDate()', () => {
93 expect(convertToDate(undefined)).toBe(undefined)
94 expect(convertToDate(null)).toBe(null)
95 expect(() => convertToDate('')).toThrow(new Error("Cannot convert to date: ''"))
96 expect(() => convertToDate('00:70:61')).toThrow(new Error("Cannot convert to date: '00:70:61'"))
97 expect(convertToDate(0)).toStrictEqual(new Date('1970-01-01T00:00:00.000Z'))
98 expect(convertToDate(-1)).toStrictEqual(new Date('1969-12-31T23:59:59.999Z'))
99 const dateStr
= '2020-01-01T00:00:00.000Z'
100 let date
= convertToDate(dateStr
)
101 expect(date
).toBeInstanceOf(Date)
102 expect(date
).toStrictEqual(new Date(dateStr
))
103 date
= convertToDate(new Date(dateStr
))
104 expect(date
).toBeInstanceOf(Date)
105 expect(date
).toStrictEqual(new Date(dateStr
))
108 await it('Verify convertToInt()', () => {
109 expect(convertToInt(undefined)).toBe(0)
110 expect(convertToInt(null)).toBe(0)
111 expect(convertToInt(0)).toBe(0)
112 const randomInteger
= getRandomInteger()
113 expect(convertToInt(randomInteger
)).toEqual(randomInteger
)
114 expect(convertToInt('-1')).toBe(-1)
115 expect(convertToInt('1')).toBe(1)
116 expect(convertToInt('1.1')).toBe(1)
117 expect(convertToInt('1.9')).toBe(1)
118 expect(convertToInt('1.999')).toBe(1)
119 expect(convertToInt(-1)).toBe(-1)
120 expect(convertToInt(1)).toBe(1)
121 expect(convertToInt(1.1)).toBe(1)
122 expect(convertToInt(1.9)).toBe(1)
123 expect(convertToInt(1.999)).toBe(1)
126 }).toThrow("Cannot convert to integer: 'NaN'")
129 await it('Verify convertToFloat()', () => {
130 expect(convertToFloat(undefined)).toBe(0)
131 expect(convertToFloat(null)).toBe(0)
132 expect(convertToFloat(0)).toBe(0)
133 const randomFloat
= getRandomFloat()
134 expect(convertToFloat(randomFloat
)).toEqual(randomFloat
)
135 expect(convertToFloat('-1')).toBe(-1)
136 expect(convertToFloat('1')).toBe(1)
137 expect(convertToFloat('1.1')).toBe(1.1)
138 expect(convertToFloat('1.9')).toBe(1.9)
139 expect(convertToFloat('1.999')).toBe(1.999)
140 expect(convertToFloat(-1)).toBe(-1)
141 expect(convertToFloat(1)).toBe(1)
142 expect(convertToFloat(1.1)).toBe(1.1)
143 expect(convertToFloat(1.9)).toBe(1.9)
144 expect(convertToFloat(1.999)).toBe(1.999)
146 convertToFloat('NaN')
147 }).toThrow("Cannot convert to float: 'NaN'")
150 await it('Verify convertToBoolean()', () => {
151 expect(convertToBoolean(undefined)).toBe(false)
152 expect(convertToBoolean(null)).toBe(false)
153 expect(convertToBoolean('true')).toBe(true)
154 expect(convertToBoolean('false')).toBe(false)
155 expect(convertToBoolean('TRUE')).toBe(true)
156 expect(convertToBoolean('FALSE')).toBe(false)
157 expect(convertToBoolean('1')).toBe(true)
158 expect(convertToBoolean('0')).toBe(false)
159 expect(convertToBoolean(1)).toBe(true)
160 expect(convertToBoolean(0)).toBe(false)
161 expect(convertToBoolean(true)).toBe(true)
162 expect(convertToBoolean(false)).toBe(false)
163 expect(convertToBoolean('')).toBe(false)
164 expect(convertToBoolean('NoNBoolean')).toBe(false)
167 await it('Verify secureRandom()', () => {
168 const random
= secureRandom()
169 expect(typeof random
=== 'number').toBe(true)
170 expect(random
).toBeGreaterThanOrEqual(0)
171 expect(random
).toBeLessThan(1)
174 await it('Verify getRandomInteger()', () => {
175 let randomInteger
= getRandomInteger()
176 expect(Number.isSafeInteger(randomInteger
)).toBe(true)
177 expect(randomInteger
).toBeGreaterThanOrEqual(0)
178 expect(randomInteger
).toBeLessThanOrEqual(Constants
.MAX_RANDOM_INTEGER
)
179 expect(randomInteger
).not
.toEqual(getRandomInteger())
180 randomInteger
= getRandomInteger(0, -Constants
.MAX_RANDOM_INTEGER
)
181 expect(randomInteger
).toBeGreaterThanOrEqual(-Constants
.MAX_RANDOM_INTEGER
)
182 expect(randomInteger
).toBeLessThanOrEqual(0)
183 expect(() => getRandomInteger(0, 1)).toThrow(
184 'The value of "max" is out of range. It must be greater than the value of "min" (1). Received 1'
186 expect(() => getRandomInteger(-1)).toThrow(
187 'The value of "max" is out of range. It must be greater than the value of "min" (0). Received 0'
189 expect(() => getRandomInteger(Constants
.MAX_RANDOM_INTEGER
+ 1)).toThrow(
190 `The value of "max" is out of range. It must be <= ${
191 Constants.MAX_RANDOM_INTEGER + 1
192 }. Received 281_474_976_710_656`
194 randomInteger
= getRandomInteger(2, 1)
195 expect(randomInteger
).toBeGreaterThanOrEqual(1)
196 expect(randomInteger
).toBeLessThanOrEqual(2)
199 randomInteger
= getRandomInteger(maximum
, minimum
)
200 expect(randomInteger
).toBeLessThanOrEqual(Math.floor(maximum
))
201 expect(randomInteger
).toBeGreaterThanOrEqual(Math.ceil(minimum
))
204 await it('Verify roundTo()', () => {
205 expect(roundTo(0, 2)).toBe(0)
206 expect(roundTo(0.5, 0)).toBe(1)
207 expect(roundTo(0.5, 2)).toBe(0.5)
208 expect(roundTo(-0.5, 0)).toBe(-1)
209 expect(roundTo(-0.5, 2)).toBe(-0.5)
210 expect(roundTo(1.005, 0)).toBe(1)
211 expect(roundTo(1.005, 2)).toBe(1.01)
212 expect(roundTo(2.175, 2)).toBe(2.18)
213 expect(roundTo(5.015, 2)).toBe(5.02)
214 expect(roundTo(-1.005, 2)).toBe(-1.01)
215 expect(roundTo(-2.175, 2)).toBe(-2.18)
216 expect(roundTo(-5.015, 2)).toBe(-5.02)
219 await it('Verify getRandomFloat()', () => {
220 let randomFloat
= getRandomFloat()
221 expect(typeof randomFloat
=== 'number').toBe(true)
222 expect(randomFloat
).toBeGreaterThanOrEqual(0)
223 expect(randomFloat
).toBeLessThanOrEqual(Number.MAX_VALUE
)
224 expect(randomFloat
).not
.toEqual(getRandomFloat())
225 expect(() => getRandomFloat(0, 1)).toThrow(new RangeError('Invalid interval'))
226 expect(() => getRandomFloat(Number.MAX_VALUE
, -Number.MAX_VALUE
)).toThrow(
227 new RangeError('Invalid interval')
229 randomFloat
= getRandomFloat(0, -Number.MAX_VALUE
)
230 expect(randomFloat
).toBeGreaterThanOrEqual(-Number.MAX_VALUE
)
231 expect(randomFloat
).toBeLessThanOrEqual(0)
234 await it('Verify extractTimeSeriesValues()', () => {
235 expect(extractTimeSeriesValues([])).toEqual([])
236 expect(extractTimeSeriesValues([{ timestamp
: Date.now(), value
: 1.1 }])).toEqual([1.1])
238 extractTimeSeriesValues([
239 { timestamp
: Date.now(), value
: 1.1 },
240 { timestamp
: Date.now(), value
: 2.2 }
242 ).toEqual([1.1, 2.2])
245 await it('Verify isObject()', () => {
246 expect(isObject('test')).toBe(false)
247 expect(isObject(undefined)).toBe(false)
248 expect(isObject(null)).toBe(false)
249 expect(isObject(0)).toBe(false)
250 expect(isObject([])).toBe(false)
251 expect(isObject([0, 1])).toBe(false)
252 expect(isObject(['0', '1'])).toBe(false)
253 expect(isObject({})).toBe(true)
254 expect(isObject({ 1: 1 })).toBe(true)
255 expect(isObject({ 1: '1' })).toBe(true)
256 expect(isObject(new Map())).toBe(true)
257 expect(isObject(new Set())).toBe(true)
258 expect(isObject(new WeakMap())).toBe(true)
259 expect(isObject(new WeakSet())).toBe(true)
262 await it('Verify cloneObject()', () => {
264 expect(cloneObject(obj
)).toStrictEqual(obj
)
265 expect(cloneObject(obj
) === obj
).toBe(false)
266 const nestedObj
= { 1: obj
, 2: obj
}
267 expect(cloneObject(nestedObj
)).toStrictEqual(nestedObj
)
268 expect(cloneObject(nestedObj
) === nestedObj
).toBe(false)
270 expect(cloneObject(array
)).toStrictEqual(array
)
271 expect(cloneObject(array
) === array
).toBe(false)
272 const objArray
= [obj
, obj
]
273 expect(cloneObject(objArray
)).toStrictEqual(objArray
)
274 expect(cloneObject(objArray
) === objArray
).toBe(false)
275 const date
= new Date()
276 expect(cloneObject(date
)).toStrictEqual(date
)
277 expect(cloneObject(date
) === date
).toBe(false)
278 const map
= new Map([['1', '2']])
279 expect(cloneObject(map
)).toStrictEqual({})
280 const set
= new Set(['1'])
281 expect(cloneObject(set
)).toStrictEqual({})
282 // The URL object seems to have not enumerable properties
283 const url
= new URL('https://domain.tld')
284 expect(cloneObject(url
)).toStrictEqual({})
285 const weakMap
= new WeakMap([[{ 1: 1 }, { 2: 2 }]])
286 expect(cloneObject(weakMap
)).toStrictEqual({})
287 const weakSet
= new WeakSet([{ 1: 1 }, { 2: 2 }])
288 expect(cloneObject(weakSet
)).toStrictEqual({})
291 await it('Verify hasOwnProp()', () => {
292 expect(hasOwnProp('test', '')).toBe(false)
293 expect(hasOwnProp(undefined, '')).toBe(false)
294 expect(hasOwnProp(null, '')).toBe(false)
295 expect(hasOwnProp([], '')).toBe(false)
296 expect(hasOwnProp({}, '')).toBe(false)
297 expect(hasOwnProp({ 1: 1 }, 1)).toBe(true)
298 expect(hasOwnProp({ 1: 1 }, '1')).toBe(true)
299 expect(hasOwnProp({ 1: 1 }, 2)).toBe(false)
300 expect(hasOwnProp({ 1: 1 }, '2')).toBe(false)
301 expect(hasOwnProp({ 1: '1' }, '1')).toBe(true)
302 expect(hasOwnProp({ 1: '1' }, 1)).toBe(true)
303 expect(hasOwnProp({ 1: '1' }, '2')).toBe(false)
304 expect(hasOwnProp({ 1: '1' }, 2)).toBe(false)
307 await it('Verify isIterable()', () => {
308 expect(isIterable('')).toBe(true)
309 expect(isIterable(' ')).toBe(true)
310 expect(isIterable('test')).toBe(true)
311 expect(isIterable(undefined)).toBe(false)
312 expect(isIterable(null)).toBe(false)
313 expect(isIterable(0)).toBe(false)
314 expect(isIterable([0, 1])).toBe(true)
315 expect(isIterable({ 1: 1 })).toBe(false)
316 expect(isIterable(new Map())).toBe(true)
317 expect(isIterable(new Set())).toBe(true)
318 expect(isIterable(new WeakMap())).toBe(false)
319 expect(isIterable(new WeakSet())).toBe(false)
322 await it('Verify isEmptyString()', () => {
323 expect(isEmptyString('')).toBe(true)
324 expect(isEmptyString(' ')).toBe(true)
325 expect(isEmptyString(' ')).toBe(true)
326 expect(isEmptyString('test')).toBe(false)
327 expect(isEmptyString(' test')).toBe(false)
328 expect(isEmptyString('test ')).toBe(false)
329 expect(isEmptyString(undefined)).toBe(true)
330 expect(isEmptyString(null)).toBe(true)
331 expect(isEmptyString(0)).toBe(false)
332 expect(isEmptyString({})).toBe(false)
333 expect(isEmptyString([])).toBe(false)
334 expect(isEmptyString(new Map())).toBe(false)
335 expect(isEmptyString(new Set())).toBe(false)
336 expect(isEmptyString(new WeakMap())).toBe(false)
337 expect(isEmptyString(new WeakSet())).toBe(false)
340 await it('Verify isNotEmptyString()', () => {
341 expect(isNotEmptyString('')).toBe(false)
342 expect(isNotEmptyString(' ')).toBe(false)
343 expect(isNotEmptyString(' ')).toBe(false)
344 expect(isNotEmptyString('test')).toBe(true)
345 expect(isNotEmptyString(' test')).toBe(true)
346 expect(isNotEmptyString('test ')).toBe(true)
347 expect(isNotEmptyString(undefined)).toBe(false)
348 expect(isNotEmptyString(null)).toBe(false)
349 expect(isNotEmptyString(0)).toBe(false)
350 expect(isNotEmptyString({})).toBe(false)
351 expect(isNotEmptyString([])).toBe(false)
352 expect(isNotEmptyString(new Map())).toBe(false)
353 expect(isNotEmptyString(new Set())).toBe(false)
354 expect(isNotEmptyString(new WeakMap())).toBe(false)
355 expect(isNotEmptyString(new WeakSet())).toBe(false)
358 await it('Verify isUndefined()', () => {
359 expect(isUndefined(undefined)).toBe(true)
360 expect(isUndefined(null)).toBe(false)
361 expect(isUndefined('')).toBe(false)
362 expect(isUndefined(0)).toBe(false)
363 expect(isUndefined({})).toBe(false)
364 expect(isUndefined([])).toBe(false)
365 expect(isUndefined(new Map())).toBe(false)
366 expect(isUndefined(new Set())).toBe(false)
367 expect(isUndefined(new WeakMap())).toBe(false)
368 expect(isUndefined(new WeakSet())).toBe(false)
371 await it('Verify isNullOrUndefined()', () => {
372 expect(isNullOrUndefined(undefined)).toBe(true)
373 expect(isNullOrUndefined(null)).toBe(true)
374 expect(isNullOrUndefined('')).toBe(false)
375 expect(isNullOrUndefined(0)).toBe(false)
376 expect(isNullOrUndefined({})).toBe(false)
377 expect(isNullOrUndefined([])).toBe(false)
378 expect(isNullOrUndefined(new Map())).toBe(false)
379 expect(isNullOrUndefined(new Set())).toBe(false)
380 expect(isNullOrUndefined(new WeakMap())).toBe(false)
381 expect(isNullOrUndefined(new WeakSet())).toBe(false)
384 await it('Verify isEmptyArray()', () => {
385 expect(isEmptyArray([])).toBe(true)
386 expect(isEmptyArray([1, 2])).toBe(false)
387 expect(isEmptyArray(['1', '2'])).toBe(false)
388 expect(isEmptyArray(undefined)).toBe(false)
389 expect(isEmptyArray(null)).toBe(false)
390 expect(isEmptyArray('')).toBe(false)
391 expect(isEmptyArray('test')).toBe(false)
392 expect(isEmptyArray(0)).toBe(false)
393 expect(isEmptyArray({})).toBe(false)
394 expect(isEmptyArray(new Map())).toBe(false)
395 expect(isEmptyArray(new Set())).toBe(false)
396 expect(isEmptyArray(new WeakMap())).toBe(false)
397 expect(isEmptyArray(new WeakSet())).toBe(false)
400 await it('Verify isNotEmptyArray()', () => {
401 expect(isNotEmptyArray([])).toBe(false)
402 expect(isNotEmptyArray([1, 2])).toBe(true)
403 expect(isNotEmptyArray(['1', '2'])).toBe(true)
404 expect(isNotEmptyArray(undefined)).toBe(false)
405 expect(isNotEmptyArray(null)).toBe(false)
406 expect(isNotEmptyArray('')).toBe(false)
407 expect(isNotEmptyArray('test')).toBe(false)
408 expect(isNotEmptyArray(0)).toBe(false)
409 expect(isNotEmptyArray({})).toBe(false)
410 expect(isNotEmptyArray(new Map())).toBe(false)
411 expect(isNotEmptyArray(new Set())).toBe(false)
412 expect(isNotEmptyArray(new WeakMap())).toBe(false)
413 expect(isNotEmptyArray(new WeakSet())).toBe(false)
416 await it('Verify isEmptyObject()', () => {
417 expect(isEmptyObject({})).toBe(true)
418 expect(isEmptyObject({ 1: 1, 2: 2 })).toBe(false)
419 expect(isEmptyObject(new Map())).toBe(false)
420 expect(isEmptyObject(new Set())).toBe(false)
421 expect(isEmptyObject(new WeakMap())).toBe(false)
422 expect(isEmptyObject(new WeakSet())).toBe(false)
425 await it('Verify isArraySorted()', () => {
427 isArraySorted([], (a
, b
) => {
432 isArraySorted([1], (a
, b
) => {
436 expect(isArraySorted
<number>([1, 2, 3, 4, 5], (a
, b
) => a
- b
)).toBe(true)
437 expect(isArraySorted
<number>([1, 2, 3, 5, 4], (a
, b
) => a
- b
)).toBe(false)
438 expect(isArraySorted
<number>([2, 1, 3, 4, 5], (a
, b
) => a
- b
)).toBe(false)
441 await it('Verify once()', () => {
443 const fn
= (): number => ++called
444 const onceFn
= once(fn
, this)
445 const result1
= onceFn()
446 expect(called
).toBe(1)
447 expect(result1
).toBe(1)
448 const result2
= onceFn()
449 expect(called
).toBe(1)
450 expect(result2
).toBe(1)
451 const result3
= onceFn()
452 expect(called
).toBe(1)
453 expect(result3
).toBe(1)
456 await it('Verify min()', () => {
457 expect(min()).toBe(Infinity)
458 expect(min(0, 1)).toBe(0)
459 expect(min(1, 0)).toBe(0)
460 expect(min(0, -1)).toBe(-1)
461 expect(min(-1, 0)).toBe(-1)
464 await it('Verify max()', () => {
465 expect(max()).toBe(-Infinity)
466 expect(max(0, 1)).toBe(1)
467 expect(max(1, 0)).toBe(1)
468 expect(max(0, -1)).toBe(0)
469 expect(max(-1, 0)).toBe(0)