@qrvey/utils 1.1.2 → 1.1.6

package/test/general/array/filterNestedTree.test.js

@@ -0,0 +1,115 @@
+const { filterNestedTree } = require('../../../dist/cjs');
+
+const filters = [
+    {
+        expressions: [
+            {
+                expressions: {
+                    id: '123',
+                    values: [{
+                        enabled: true,
+                        value: 'Hello World',
+                    }]
+                },
+                operator: 'OR'
+            },
+            {
+                expressions: {
+                    id: '345',
+                    values: [{
+                        enabled: true,
+                        value: 'Hello World 2',
+                    }]
+                },
+                operator: 'OR'
+            }
+        ],
+        operator: 'AND'
+    }
+];
+
+const condition = (expression) => expression.expressions.id === '123';
+const noMatchCondition = (expression) => expression.expressions.id === '890';
+
+describe('Testing Undefined arguments', function () {
+    const emptyVariable = undefined;
+    const emptyArray = [];
+
+    const emptyString = '';
+
+    test('No Arguments', function () {
+        const emptyFilter = filterNestedTree();
+        expect(emptyFilter).toEqual([]);
+    });
+    
+    test('Undefined First argument', function () {
+        const emptyFilter = filterNestedTree(emptyVariable);
+        expect(emptyFilter).toEqual([]);
+    });
+
+    test('Empty First argument', function () {
+        const undefinedVariable = filterNestedTree(emptyArray);
+        expect(undefinedVariable).toBe(emptyArray);
+    });
+
+    test('Undefined first argument and undefined second argument', function () {
+        const undefinedVariable = filterNestedTree(emptyVariable, emptyVariable);
+        expect(undefinedVariable).toEqual([]);
+    });
+
+    test('Undefined first argument and empty second argument', function () {
+        const undefinedVariable = filterNestedTree(emptyVariable, emptyString);
+        expect(undefinedVariable).toEqual([]);
+    });
+
+    test('Empty first argument and empty second argument', function () {
+        const undefinedVariable = filterNestedTree(emptyArray, emptyString);
+        expect(undefinedVariable).toBe(emptyArray);
+    });
+
+    test('Undefined first argument, undefined second argument and undefined third argument', function () {
+        const undefinedVariable = filterNestedTree(emptyVariable, emptyVariable, emptyVariable);
+        expect(undefinedVariable).toEqual([]);
+    });
+});
+
+describe('Testing different arguments as expected', function () {
+    const first1 = 1;
+    const second1 = true;
+    const third1 = 'Hello';
+
+    test('Numeric first argument', function () {
+        const fNTfirst1 = filterNestedTree(first1, 'expressions', condition);
+        expect(fNTfirst1).toBe(first1);
+    });
+
+    test('Boolean second argument', function () {
+        const fNTSecond1 = filterNestedTree(filters, second1, condition);
+        expect(fNTSecond1).toBe(filters);
+    });
+
+    test('String Third argument', function () {
+        const fNTSecond1 = filterNestedTree(filters, 'expressions', third1);
+        expect(fNTSecond1).toBe(filters);
+    });
+});
+
+describe('Filtering array by condition', function () {
+    test('Regular scenario', function () {
+        const fNTfilters = filterNestedTree(filters, 'expressions', condition);
+        expect(fNTfilters).not.toEqual(expect.arrayContaining(filters));
+        expect(fNTfilters[0].expressions).toHaveLength(1);
+        expect(fNTfilters[0].expressions[1]).toBeUndefined();
+    });
+
+    test('No child is matched', function () {
+        const fNTfilters = filterNestedTree(filters, 'expressionss', condition);
+        expect(fNTfilters).toEqual([]);
+    });
+
+    test('No child is matched', function () {
+        const fNTfilters = filterNestedTree(filters, 'expressions', noMatchCondition);
+        expect(fNTfilters).not.toEqual(expect.arrayContaining(filters));
+        expect(fNTfilters[0].expressions).toHaveLength(0);
+    });
+});

package/test/general/mix/getTag.test.js

@@ -0,0 +1,101 @@
+const { getTag } = require('../../../dist/cjs');
+
+const tag1 = '[object Null]';
+const tag2 = '[object Undefined]';
+const tag3 = '[object Array]';
+const tag4 = '[object Object]';
+const tag5 = '[object String]';
+const tag6 = '[object Date]';
+const tag7 = '[object Boolean]';
+const tag8 = '[object Number]';
+const tag9 = '[object Map]';
+const tag10 = '[object Set]';
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+    const empty4 = '';
+    const empty5 = null;
+
+    test('No arguments', function () {
+        const tag = getTag();
+        expect(tag).toBe(tag2);
+    });
+
+    test('Undefined variable', function () {
+        const tag = getTag(empty1);
+        expect(tag).toBe(tag2);
+    });
+
+    test('Empty Array variable', function () {
+        const tag = getTag(empty2);
+        expect(tag).toBe(tag3);
+    });
+
+    test('Empty Object variable', function () {
+        const tag = getTag(empty3);
+        expect(tag).toBe(tag4);
+    });
+
+    test('Empty String variable', function () {
+        const tag = getTag(empty4);
+        expect(tag).toBe(tag5);
+    });
+
+    test('Null variable', function () {
+        const tag = getTag(empty5);
+        expect(tag).toBe(tag1);
+    });
+});
+
+describe('Regular scenarios', function () {
+    const variable1 = ['Hello', 'World'];
+    const variable2 = { tag1: 'Hello', tag2: 'World' };
+    const variable3 = 'Hello';
+    const variable4 = new Date('2021-10-01');
+    const variable5 = true;
+    const variable6 = 1;
+    const variable7 = new Map();
+    const variable8 = new Set();
+
+    test('Array type', function () {
+        const tag = getTag(variable1);
+        expect(tag).toBe(tag3);
+    });
+
+    test('Object type', function () {
+        const tag = getTag(variable2);
+        expect(tag).toBe(tag4);
+    });
+
+    test('String type' , function () {
+        const tag = getTag(variable3);
+        expect(tag).toBe(tag5);
+    });
+
+    test('Date Type' , function () {
+        const tag = getTag(variable4);
+        expect(tag).toBe(tag6);
+    });
+
+    test('Boolean Type' , function () {
+        const tag = getTag(variable5);
+        expect(tag).toBe(tag7);
+    });
+
+    test('Numeric Type' , function () {
+        const tag = getTag(variable6);
+        expect(tag).toBe(tag8);
+    });
+
+    test('Map Type' , function () {
+        const tag = getTag(variable7);
+        expect(tag).toBe(tag9);
+    });
+
+    test('Set Type' , function () {
+        const tag = getTag(variable8);
+        expect(tag).toBe(tag10);
+    });
+});

package/test/general/mix/isEmpty.test.js

@@ -9,27 +9,27 @@ describe('Validating the emptyness of the given argument', function () {
 
     test('Undefined', function () {
         const empty = isEmpty(empty1);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Null type', function () {
         const empty = isEmpty(empty2);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Empty string', function () {
         const empty = isEmpty(empty3);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Array without items', function () {
         const empty = isEmpty(empty4);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Object wihtout properties', function () {
         const empty = isEmpty(empty5);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 });
 
@@ -44,63 +44,63 @@ describe('Validating falsy arguments', function () {
     
     test('Zero number', function () {
         const empty = isEmpty(falsyEmpty1);
-        expect(false).toEqual(empty);
+        expect(false).toEqual(false);
     });
 
     test('Zero number with Falsy', function () {
         const empty = isEmpty(falsyEmpty1, true);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Zero floating number', function () {
         const empty = isEmpty(falsyEmpty2);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Zero floating number with Falsy', function () {
         const empty = isEmpty(falsyEmpty2, true);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('Negative Zero number', function () {
         const empty = isEmpty(falsyEmpty3);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Negative Zero number with Falsy', function () {
         const empty = isEmpty(falsyEmpty3, true);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
     test('NaN', function () {
         const empty = isEmpty(falsyEmpty4);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('NaN with Falsy', function () {
         const empty = isEmpty(falsyEmpty4, true);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 
 
     test('Affirmative Boolean', function () {
         const empty = isEmpty(falsyEmpty5);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Affirmative Boolean with Falsy', function () {
         const empty = isEmpty(falsyEmpty5, true);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Negative Boolean', function () {
         const empty = isEmpty(falsyEmpty6);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Negative Boolean with Falsy', function () {
         const empty = isEmpty(falsyEmpty6, true);
-        expect(true).toEqual(empty);
+        expect(empty).toEqual(true);
     });
 });
 
@@ -115,36 +115,36 @@ describe('Validating non-empty arguments', function () {
 
     test('String type', function () {
         const empty = isEmpty(notEmpty1);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Array type', function () {
         const empty = isEmpty(notEmpty2);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Object type', function () {
         const empty = isEmpty(notEmpty3);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Number different to zero', function () {
         const empty = isEmpty(notEmpty4);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Zero Number in string', function () {
         const empty = isEmpty(notEmpty5);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Function type', function () {
         const empty = isEmpty(notEmpty6);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 
     test('Date object type', function () {
         const empty = isEmpty(notEmpty7);
-        expect(false).toEqual(empty);
+        expect(empty).toEqual(false);
     });
 });

package/test/general/mix/isNull.test.js

@@ -0,0 +1,72 @@
+const { isNull } = require('../../../dist/cjs');
+
+describe('Testing empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+    const empty4 = '';
+    const empty5 = null;
+
+    test('No arguments', function () {
+        const nullable = isNull();
+        expect(nullable).toBeTruthy();
+    });
+
+    test('Undefined variable', function () {
+        const nullable = isNull(empty1);
+        expect(nullable).toBeTruthy();
+    });
+
+    test('Empty Array variable', function () {
+        const nullable = isNull(empty2);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Empty Object variable', function () {
+        const nullable = isNull(empty3);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Empty String variable', function () {
+        const nullable = isNull(empty4);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Null variable', function () {
+        const nullable = isNull(empty5);
+        expect(nullable).toBeTruthy();
+    });
+});
+
+describe('Testing non-empty arguments', function () {
+    const variable1 = ['Hello', 'World'];
+    const variable2 = { tag1: 'Hello', tag2: 'World' };
+    const variable3 = 'Hello';
+    const variable4 = false;
+    const variable5 = 1;
+
+    test('Array type', function () {
+        const nullable = isNull(variable1);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Object type', function () {
+        const nullable = isNull(variable2);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('String type' , function () {
+        const nullable = isNull(variable3);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Date Type' , function () {
+        const nullable = isNull(variable4);
+        expect(nullable).toBeFalsy();
+    });
+
+    test('Boolean Type' , function () {
+        const nullable = isNull(variable5);
+        expect(nullable).toBeFalsy();
+    });
+});

package/test/general/mix/randomId.test.js

@@ -0,0 +1,134 @@
+const { randomId } = require('../../../dist/cjs');
+
+describe('Testing empty arguments', function () {
+    const empty1 = undefined;
+    
+    test('No arguments', function () {
+        const id = randomId();
+        expect(id).toHaveLength(8);
+    });
+
+    test('Undefined variable', function () {
+        const id = randomId(empty1);
+        expect(id).toHaveLength(8);
+    });
+});
+
+describe('Testing different type argument', function () {
+    const variable1 = ['Hello', 'World'];
+    const variable2 = { tag1: 'Hello', tag2: 'World' };
+    const variable3 = 'Hello';
+    const variable4 = false;
+    const variable5 = '1';
+    const variable6 = [false, 1, true, new Date()];
+
+    test('Array type', function () {
+        const id = randomId(variable1);
+        expect(id).toHaveLength(8);
+    });
+
+    test('Object type', function () {
+        const id = randomId(variable2);
+        expect(id).toHaveLength(8);
+    });
+
+    test('String type' , function () {
+        const id = randomId(variable3);
+        expect(id).toHaveLength(8);
+    });
+
+    test('Date Type' , function () {
+        const id = randomId(variable4);
+        expect(id).toHaveLength(8);
+    });
+
+    test('Boolean Type' , function () {
+        const id = randomId(variable5);
+        expect(id).toHaveLength(8);
+    });
+
+    test('Correct first argument but incorrect second one', function() {
+        const id = randomId(1, variable3);
+        expect(id).toHaveLength(1);
+    });
+
+    test('An array as second argument but incorrect item types', function() {
+        const id = randomId(1, variable6);
+        expect(id).toHaveLength(1);
+    });
+});
+
+describe('Regular scenarios', function () {
+    const length1 = 0;
+    const length2 = 1;
+    const length3 = 2;
+    const length4 = 3;
+    const length5 = 5;
+    const length6 = 8;
+    const length7 = 13;
+    const length8 = 21;
+    const length9 = 34;
+
+    test('0-lenght', function () {
+        const id = randomId(length1);
+        expect(id).toHaveLength(length1);
+    });
+
+    test('1-lenght', function () {
+        const id = randomId(length2);
+        expect(id).toHaveLength(length2);
+    });
+
+    test('2-lenght' , function () {
+        const id = randomId(length3);
+        expect(id).toHaveLength(length3);
+    });
+
+    test('3-lenght' , function () {
+        const id = randomId(length4);
+        expect(id).toHaveLength(length4);
+    });
+
+    test('5-lenght' , function () {
+        const id = randomId(length5);
+        expect(id).toHaveLength(length5);
+    });
+
+    test('8-lenght' , function () {
+        const id = randomId(length6);
+        expect(id).toHaveLength(length6);
+    });
+
+    test('13-lenght' , function () {
+        const id = randomId(length7);
+        expect(id).toHaveLength(length7);
+    });
+
+    test('21-lenght' , function () {
+        const id = randomId(length8);
+        expect(id).toHaveLength(length8);
+    });
+
+    test('34-lenght' , function () {
+        const id = randomId(length9);
+        expect(id).toHaveLength(length9);
+    });
+});
+
+describe('Excluding repeated ids', function () {
+    const length1 = 1;
+    const excludeAll = [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "_" ];
+    const excludeExcept9 = [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "_" ];
+
+    test('Excluding all excepts 9' , function () {
+        const id = randomId(length1, excludeExcept9);
+        expect(id).toHaveLength(length1);
+        expect(id).toBe("9");
+    });
+
+    test('Excluding all' , function () {
+        const id = randomId(length1, excludeAll);
+        expect(id).toHaveLength(0);
+        expect(id).toBe("");
+    });
+});

package/test/general/mix/size.test.js

@@ -0,0 +1,87 @@
+const { size } = require('../../../dist/cjs');
+
+describe('Testing empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+    const empty4 = '';
+    
+    test('No arguments', function () {
+        const _length = size();
+        expect(_length).toBe(0);
+    });
+
+    test('Undefined variable', function () {
+        const _length = size(empty1);
+        expect(_length).toBe(0);
+    });
+
+    test('Empty array variable', function () {
+        const _length = size(empty2);
+        expect(_length).toBe(0);
+    });
+
+    test('Empty object variable', function () {
+        const _length = size(empty3);
+        expect(_length).toBe(0);
+    });
+
+    test('Empty string variable', function () {
+        const _length = size(empty4);
+        expect(_length).toBe(0);
+    });
+});
+
+describe('Testing different object-type arguments', function () {
+    const variable1 = new Date();
+    const variable2 = false;
+    const variable3 = 1234;
+    const variable4 = (dig1 = 1, dig2 = 2) => dig1 + dig2;
+
+    test('Date type', function () {
+        const _length = size(variable1);
+        expect(_length).toBe(0);
+    });
+
+    test('Boolean type', function () {
+        const _length = size(variable2);
+        expect(_length).toBe(0);
+    });
+
+    test('Numeric type', function () {
+        const _length = size(variable3);
+        expect(_length).toBe(0);
+    });
+
+    test('Function type', function () {
+        const _length = size(variable4);
+        expect(_length).toBe(0);
+    });
+});
+
+describe('Regular scenarios', function () {
+    const variable1 = ['Hello', 'World'];
+    const variable2 = { tag1: 'Hello', tag2: 'World' };
+    const variable3 = [{ name: 'Jose' }, { name: 'David' }, { name: 'Eduardo' }];
+    const variable4 = "Hello World";
+
+    test('Array type', function () {
+        const _length = size(variable1);
+        expect(_length).toBe(2);
+    });
+
+    test('Object type', function () {
+        const _length = size(variable2);
+        expect(_length).toBe(2);
+    });
+
+    test('Object array type' , function () {
+        const _length = size(variable3);
+        expect(_length).toBe(3);
+    });
+
+    test('String Type' , function () {
+        const _length = size(variable4);
+        expect(_length).toBe(11);
+    });
+});