1 import { hoursToMilliseconds
, hoursToSeconds
, isValid
} from
'date-fns';
2 import { expect
} from
'expect';
4 import { Constants
} from
'../../src/utils/Constants';
11 extractTimeSeriesValues
,
12 formatDurationMilliSeconds
,
13 formatDurationSeconds
,
33 } from
'../../src/utils/Utils';
35 describe('Utils test suite', () => {
36 it('Verify generateUUID()/validateUUID()', () => {
37 const uuid
= generateUUID();
38 expect(uuid
).toBeDefined();
39 expect(uuid
.length
).toEqual(36);
40 expect(validateUUID(uuid
)).toBe(true);
41 expect(validateUUID('abcdef00-0000-4000-0000-000000000000')).toBe(true);
42 expect(validateUUID('')).toBe(false);
43 // Shall invalidate Nil UUID
44 expect(validateUUID('00000000-0000-0000-0000-000000000000')).toBe(false);
45 expect(validateUUID('987FBC9-4BED-3078-CF07A-9141BA07C9F3')).toBe(false);
48 it('Verify sleep()', async () => {
49 const start
= performance
.now();
51 const end
= performance
.now();
52 expect(end
- start
).toBeGreaterThanOrEqual(1000);
55 it('Verify formatDurationMilliSeconds()', () => {
56 expect(formatDurationMilliSeconds(0)).toBe('');
57 expect(formatDurationMilliSeconds(1000)).toBe('1 second');
58 expect(formatDurationMilliSeconds(hoursToMilliseconds(4380))).toBe('182 days 12 hours');
61 it('Verify formatDurationSeconds()', () => {
62 expect(formatDurationSeconds(0)).toBe('');
63 expect(formatDurationSeconds(1)).toBe('1 second');
64 expect(formatDurationSeconds(hoursToSeconds(4380))).toBe('182 days 12 hours');
67 it('Verify isValidTime()', () => {
68 expect(isValidTime(undefined)).toBe(false);
69 expect(isValidTime(null)).toBe(false);
70 expect(isValidTime('')).toBe(false);
71 expect(isValidTime({})).toBe(false);
72 expect(isValidTime([])).toBe(false);
73 expect(isValidTime(new Map())).toBe(false);
74 expect(isValidTime(new Set())).toBe(false);
75 expect(isValidTime(new WeakMap())).toBe(false);
76 expect(isValidTime(new WeakSet())).toBe(false);
77 expect(isValidTime(-1)).toBe(true);
78 expect(isValidTime(0)).toBe(true);
79 expect(isValidTime(1)).toBe(true);
80 expect(isValidTime(-0.5)).toBe(true);
81 expect(isValidTime(0.5)).toBe(true);
82 expect(isValidTime(new Date())).toBe(true);
85 it('Verify convertToDate()', () => {
86 expect(convertToDate(undefined)).toBe(undefined);
87 expect(convertToDate(null)).toBe(null);
88 expect(isValid(convertToDate(''))).toBe(false);
89 expect(convertToDate(0)).toStrictEqual(new Date('1970-01-01T00:00:00.000Z'));
90 const dateStr
= '2020-01-01T00:00:00.000Z';
91 let date
= convertToDate(dateStr
);
92 expect(date
).toBeInstanceOf(Date);
93 expect(date
).toStrictEqual(new Date(dateStr
));
94 date
= convertToDate(new Date(dateStr
));
95 expect(date
).toBeInstanceOf(Date);
96 expect(date
).toStrictEqual(new Date(dateStr
));
99 it('Verify convertToInt()', () => {
100 expect(convertToInt(undefined)).toBe(0);
101 expect(convertToInt(null)).toBe(0);
102 expect(convertToInt(0)).toBe(0);
103 const randomInteger
= getRandomInteger();
104 expect(convertToInt(randomInteger
)).toEqual(randomInteger
);
105 expect(convertToInt('-1')).toBe(-1);
106 expect(convertToInt('1')).toBe(1);
107 expect(convertToInt('1.1')).toBe(1);
108 expect(convertToInt('1.9')).toBe(1);
109 expect(convertToInt('1.999')).toBe(1);
110 expect(convertToInt(-1)).toBe(-1);
111 expect(convertToInt(1)).toBe(1);
112 expect(convertToInt(1.1)).toBe(1);
113 expect(convertToInt(1.9)).toBe(1);
114 expect(convertToInt(1.999)).toBe(1);
117 }).toThrow('Cannot convert to integer: NaN');
120 it('Verify convertToFloat()', () => {
121 expect(convertToFloat(undefined)).toBe(0);
122 expect(convertToFloat(null)).toBe(0);
123 expect(convertToFloat(0)).toBe(0);
124 const randomFloat
= getRandomFloat();
125 expect(convertToFloat(randomFloat
)).toEqual(randomFloat
);
126 expect(convertToFloat('-1')).toBe(-1);
127 expect(convertToFloat('1')).toBe(1);
128 expect(convertToFloat('1.1')).toBe(1.1);
129 expect(convertToFloat('1.9')).toBe(1.9);
130 expect(convertToFloat('1.999')).toBe(1.999);
131 expect(convertToFloat(-1)).toBe(-1);
132 expect(convertToFloat(1)).toBe(1);
133 expect(convertToFloat(1.1)).toBe(1.1);
134 expect(convertToFloat(1.9)).toBe(1.9);
135 expect(convertToFloat(1.999)).toBe(1.999);
137 convertToFloat('NaN');
138 }).toThrow('Cannot convert to float: NaN');
141 it('Verify convertToBoolean()', () => {
142 expect(convertToBoolean(undefined)).toBe(false);
143 expect(convertToBoolean(null)).toBe(false);
144 expect(convertToBoolean('true')).toBe(true);
145 expect(convertToBoolean('false')).toBe(false);
146 expect(convertToBoolean('TRUE')).toBe(true);
147 expect(convertToBoolean('FALSE')).toBe(false);
148 expect(convertToBoolean('1')).toBe(true);
149 expect(convertToBoolean('0')).toBe(false);
150 expect(convertToBoolean(1)).toBe(true);
151 expect(convertToBoolean(0)).toBe(false);
152 expect(convertToBoolean(true)).toBe(true);
153 expect(convertToBoolean(false)).toBe(false);
154 expect(convertToBoolean('')).toBe(false);
155 expect(convertToBoolean('NoNBoolean')).toBe(false);
158 it('Verify secureRandom()', () => {
159 const random
= secureRandom();
160 expect(typeof random
=== 'number').toBe(true);
161 expect(random
).toBeGreaterThanOrEqual(0);
162 expect(random
).toBeLessThan(1);
165 it('Verify getRandomInteger()', () => {
166 let randomInteger
= getRandomInteger();
167 expect(Number.isSafeInteger(randomInteger
)).toBe(true);
168 expect(randomInteger
).toBeGreaterThanOrEqual(0);
169 expect(randomInteger
).toBeLessThanOrEqual(Constants
.MAX_RANDOM_INTEGER
);
170 expect(randomInteger
).not
.toEqual(getRandomInteger());
171 randomInteger
= getRandomInteger(0, -Constants
.MAX_RANDOM_INTEGER
);
172 expect(randomInteger
).toBeGreaterThanOrEqual(-Constants
.MAX_RANDOM_INTEGER
);
173 expect(randomInteger
).toBeLessThanOrEqual(0);
174 expect(() => getRandomInteger(0, 1)).toThrowError(
175 'The value of "max" is out of range. It must be greater than the value of "min" (1). Received 1',
177 expect(() => getRandomInteger(-1)).toThrowError(
178 'The value of "max" is out of range. It must be greater than the value of "min" (0). Received 0',
180 expect(() => getRandomInteger(Constants
.MAX_RANDOM_INTEGER
+ 1)).toThrowError(
181 `The value of "max" is out of range. It must be <= ${
182 Constants.MAX_RANDOM_INTEGER + 1
183 }. Received 281_474_976_710_656`,
185 randomInteger
= getRandomInteger(2, 1);
186 expect(randomInteger
).toBeGreaterThanOrEqual(1);
187 expect(randomInteger
).toBeLessThanOrEqual(2);
190 randomInteger
= getRandomInteger(max
, min
);
191 expect(randomInteger
).toBeGreaterThanOrEqual(Math.ceil(min
));
192 expect(randomInteger
).toBeLessThanOrEqual(Math.floor(max
));
195 it('Verify roundTo()', () => {
196 expect(roundTo(0, 2)).toBe(0);
197 expect(roundTo(0.5, 0)).toBe(1);
198 expect(roundTo(0.5, 2)).toBe(0.5);
199 expect(roundTo(-0.5, 0)).toBe(-1);
200 expect(roundTo(-0.5, 2)).toBe(-0.5);
201 expect(roundTo(1.005, 0)).toBe(1);
202 expect(roundTo(1.005, 2)).toBe(1.01);
203 expect(roundTo(2.175, 2)).toBe(2.18);
204 expect(roundTo(5.015, 2)).toBe(5.02);
205 expect(roundTo(-1.005, 2)).toBe(-1.01);
206 expect(roundTo(-2.175, 2)).toBe(-2.18);
207 expect(roundTo(-5.015, 2)).toBe(-5.02);
210 it('Verify getRandomFloat()', () => {
211 let randomFloat
= getRandomFloat();
212 expect(typeof randomFloat
=== 'number').toBe(true);
213 expect(randomFloat
).toBeGreaterThanOrEqual(0);
214 expect(randomFloat
).toBeLessThanOrEqual(Number.MAX_VALUE
);
215 expect(randomFloat
).not
.toEqual(getRandomFloat());
216 expect(() => getRandomFloat(0, 1)).toThrowError(new RangeError('Invalid interval'));
217 expect(() => getRandomFloat(Number.MAX_VALUE
, -Number.MAX_VALUE
)).toThrowError(
218 new RangeError('Invalid interval'),
220 randomFloat
= getRandomFloat(0, -Number.MAX_VALUE
);
221 expect(randomFloat
).toBeGreaterThanOrEqual(-Number.MAX_VALUE
);
222 expect(randomFloat
).toBeLessThanOrEqual(0);
225 it('Verify extractTimeSeriesValues()', () => {
226 expect(extractTimeSeriesValues([])).toEqual([]);
227 expect(extractTimeSeriesValues([{ timestamp
: Date.now(), value
: 1.1 }])).toEqual([1.1]);
229 extractTimeSeriesValues([
230 { timestamp
: Date.now(), value
: 1.1 },
231 { timestamp
: Date.now(), value
: 2.2 },
233 ).toEqual([1.1, 2.2]);
236 it('Verify isObject()', () => {
237 expect(isObject('test')).toBe(false);
238 expect(isObject(undefined)).toBe(false);
239 expect(isObject(null)).toBe(false);
240 expect(isObject(0)).toBe(false);
241 expect(isObject([])).toBe(false);
242 expect(isObject([0, 1])).toBe(false);
243 expect(isObject(['0', '1'])).toBe(false);
244 expect(isObject({})).toBe(true);
245 expect(isObject({ 1: 1 })).toBe(true);
246 expect(isObject({ '1': '1' })).toBe(true);
247 expect(isObject(new Map())).toBe(true);
248 expect(isObject(new Set())).toBe(true);
249 expect(isObject(new WeakMap())).toBe(true);
250 expect(isObject(new WeakSet())).toBe(true);
253 it('Verify cloneObject()', () => {
254 const obj
= { 1: 1 };
255 expect(cloneObject(obj
)).toStrictEqual(obj
);
256 expect(cloneObject(obj
) === obj
).toBe(false);
257 const nestedObj
= { 1: obj
, 2: obj
};
258 expect(cloneObject(nestedObj
)).toStrictEqual(nestedObj
);
259 expect(cloneObject(nestedObj
) === nestedObj
).toBe(false);
260 const array
= [1, 2];
261 expect(cloneObject(array
)).toStrictEqual(array
);
262 expect(cloneObject(array
) === array
).toBe(false);
263 const objArray
= [obj
, obj
];
264 expect(cloneObject(objArray
)).toStrictEqual(objArray
);
265 expect(cloneObject(objArray
) === objArray
).toBe(false);
266 const date
= new Date();
267 expect(cloneObject(date
)).toStrictEqual(date
);
268 expect(cloneObject(date
) === date
).toBe(false);
269 const map
= new Map([['1', '2']]);
270 expect(cloneObject(map
)).toStrictEqual({});
271 const set
= new Set(['1']);
272 expect(cloneObject(set
)).toStrictEqual({});
273 // The URL object seems to have not enumerable properties
274 const url
= new URL('https://domain.tld');
275 expect(cloneObject(url
)).toStrictEqual({});
276 const weakMap
= new WeakMap([[{ 1: 1 }, { 2: 2 }]]);
277 expect(cloneObject(weakMap
)).toStrictEqual({});
278 const weakSet
= new WeakSet([{ 1: 1 }, { 2: 2 }]);
279 expect(cloneObject(weakSet
)).toStrictEqual({});
282 it('Verify hasOwnProp()', () => {
283 expect(hasOwnProp('test', '')).toBe(false);
284 expect(hasOwnProp(undefined, '')).toBe(false);
285 expect(hasOwnProp(null, '')).toBe(false);
286 expect(hasOwnProp([], '')).toBe(false);
287 expect(hasOwnProp({}, '')).toBe(false);
288 expect(hasOwnProp({ 1: 1 }, 1)).toBe(true);
289 expect(hasOwnProp({ 1: 1 }, '1')).toBe(true);
290 expect(hasOwnProp({ 1: 1 }, 2)).toBe(false);
291 expect(hasOwnProp({ 1: 1 }, '2')).toBe(false);
292 expect(hasOwnProp({ '1': '1' }, '1')).toBe(true);
293 expect(hasOwnProp({ '1': '1' }, 1)).toBe(true);
294 expect(hasOwnProp({ '1': '1' }, '2')).toBe(false);
295 expect(hasOwnProp({ '1': '1' }, 2)).toBe(false);
298 it('Verify isIterable()', () => {
299 expect(isIterable('')).toBe(true);
300 expect(isIterable(' ')).toBe(true);
301 expect(isIterable('test')).toBe(true);
302 expect(isIterable(undefined)).toBe(false);
303 expect(isIterable(null)).toBe(false);
304 expect(isIterable(0)).toBe(false);
305 expect(isIterable([0, 1])).toBe(true);
306 expect(isIterable({ 1: 1 })).toBe(false);
307 expect(isIterable(new Map())).toBe(true);
308 expect(isIterable(new Set())).toBe(true);
309 expect(isIterable(new WeakMap())).toBe(false);
310 expect(isIterable(new WeakSet())).toBe(false);
313 it('Verify isEmptyString()', () => {
314 expect(isEmptyString('')).toBe(true);
315 expect(isEmptyString(' ')).toBe(true);
316 expect(isEmptyString(' ')).toBe(true);
317 expect(isEmptyString('test')).toBe(false);
318 expect(isEmptyString(' test')).toBe(false);
319 expect(isEmptyString('test ')).toBe(false);
320 expect(isEmptyString(undefined)).toBe(true);
321 expect(isEmptyString(null)).toBe(true);
322 expect(isEmptyString(0)).toBe(false);
323 expect(isEmptyString({})).toBe(false);
324 expect(isEmptyString([])).toBe(false);
325 expect(isEmptyString(new Map())).toBe(false);
326 expect(isEmptyString(new Set())).toBe(false);
327 expect(isEmptyString(new WeakMap())).toBe(false);
328 expect(isEmptyString(new WeakSet())).toBe(false);
331 it('Verify isNotEmptyString()', () => {
332 expect(isNotEmptyString('')).toBe(false);
333 expect(isNotEmptyString(' ')).toBe(false);
334 expect(isNotEmptyString(' ')).toBe(false);
335 expect(isNotEmptyString('test')).toBe(true);
336 expect(isNotEmptyString(' test')).toBe(true);
337 expect(isNotEmptyString('test ')).toBe(true);
338 expect(isNotEmptyString(undefined)).toBe(false);
339 expect(isNotEmptyString(null)).toBe(false);
340 expect(isNotEmptyString(0)).toBe(false);
341 expect(isNotEmptyString({})).toBe(false);
342 expect(isNotEmptyString([])).toBe(false);
343 expect(isNotEmptyString(new Map())).toBe(false);
344 expect(isNotEmptyString(new Set())).toBe(false);
345 expect(isNotEmptyString(new WeakMap())).toBe(false);
346 expect(isNotEmptyString(new WeakSet())).toBe(false);
349 it('Verify isUndefined()', () => {
350 expect(isUndefined(undefined)).toBe(true);
351 expect(isUndefined(null)).toBe(false);
352 expect(isUndefined('')).toBe(false);
353 expect(isUndefined(0)).toBe(false);
354 expect(isUndefined({})).toBe(false);
355 expect(isUndefined([])).toBe(false);
356 expect(isUndefined(new Map())).toBe(false);
357 expect(isUndefined(new Set())).toBe(false);
358 expect(isUndefined(new WeakMap())).toBe(false);
359 expect(isUndefined(new WeakSet())).toBe(false);
362 it('Verify isNullOrUndefined()', () => {
363 expect(isNullOrUndefined(undefined)).toBe(true);
364 expect(isNullOrUndefined(null)).toBe(true);
365 expect(isNullOrUndefined('')).toBe(false);
366 expect(isNullOrUndefined(0)).toBe(false);
367 expect(isNullOrUndefined({})).toBe(false);
368 expect(isNullOrUndefined([])).toBe(false);
369 expect(isNullOrUndefined(new Map())).toBe(false);
370 expect(isNullOrUndefined(new Set())).toBe(false);
371 expect(isNullOrUndefined(new WeakMap())).toBe(false);
372 expect(isNullOrUndefined(new WeakSet())).toBe(false);
375 it('Verify isEmptyArray()', () => {
376 expect(isEmptyArray([])).toBe(true);
377 expect(isEmptyArray([1, 2])).toBe(false);
378 expect(isEmptyArray(['1', '2'])).toBe(false);
379 expect(isEmptyArray(undefined)).toBe(false);
380 expect(isEmptyArray(null)).toBe(false);
381 expect(isEmptyArray('')).toBe(false);
382 expect(isEmptyArray('test')).toBe(false);
383 expect(isEmptyArray(0)).toBe(false);
384 expect(isEmptyArray({})).toBe(false);
385 expect(isEmptyArray(new Map())).toBe(false);
386 expect(isEmptyArray(new Set())).toBe(false);
387 expect(isEmptyArray(new WeakMap())).toBe(false);
388 expect(isEmptyArray(new WeakSet())).toBe(false);
391 it('Verify isNotEmptyArray()', () => {
392 expect(isNotEmptyArray([])).toBe(false);
393 expect(isNotEmptyArray([1, 2])).toBe(true);
394 expect(isNotEmptyArray(['1', '2'])).toBe(true);
395 expect(isNotEmptyArray(undefined)).toBe(false);
396 expect(isNotEmptyArray(null)).toBe(false);
397 expect(isNotEmptyArray('')).toBe(false);
398 expect(isNotEmptyArray('test')).toBe(false);
399 expect(isNotEmptyArray(0)).toBe(false);
400 expect(isNotEmptyArray({})).toBe(false);
401 expect(isNotEmptyArray(new Map())).toBe(false);
402 expect(isNotEmptyArray(new Set())).toBe(false);
403 expect(isNotEmptyArray(new WeakMap())).toBe(false);
404 expect(isNotEmptyArray(new WeakSet())).toBe(false);
407 it('Verify isEmptyObject()', () => {
408 expect(isEmptyObject({})).toBe(true);
409 expect(isEmptyObject({ 1: 1, 2: 2 })).toBe(false);
410 expect(isEmptyObject(new Map())).toBe(false);
411 expect(isEmptyObject(new Set())).toBe(false);
412 expect(isEmptyObject(new WeakMap())).toBe(false);
413 expect(isEmptyObject(new WeakSet())).toBe(false);
416 it('Verify isArraySorted()', () => {
418 isArraySorted([], (a
, b
) => {
423 isArraySorted([1], (a
, b
) => {
427 expect(isArraySorted
<number>([1, 2, 3, 4, 5], (a
, b
) => a
- b
)).toBe(true);
428 expect(isArraySorted
<number>([1, 2, 3, 5, 4], (a
, b
) => a
- b
)).toBe(false);
429 expect(isArraySorted
<number>([2, 1, 3, 4, 5], (a
, b
) => a
- b
)).toBe(false);