@qrvey/utils 1.1.0-9 → 1.1.2-1

package/test/general/array/delete.test.js

@@ -0,0 +1,64 @@
+const { ArrayDelete } = require('../../../dist/cjs');
+
+describe('Non-array variables', function () {
+    const emptyVariable = undefined;
+    const emptyArray = [];
+    const unexpectedVariable1 = 1;
+    const unexpectedVariable2 = 'Hello World';
+    const unexpectedVariable3 = { tag1: 'Hello', tag2: 'World' };
+    
+    test('Undefined variable', function () {
+        const undefinedVariable = ArrayDelete(emptyVariable, 0);
+        expect(undefinedVariable).toBeUndefined();
+    });
+
+    test('Empty array', function () {
+        const aDEmptyArray = ArrayDelete(emptyArray, 0);
+        expect(aDEmptyArray).toBe(emptyArray);
+    });
+
+    test('Numeric value', function () {
+        const aDUnexpectedVariable1 = ArrayDelete(unexpectedVariable1, 0);
+        expect(aDUnexpectedVariable1).toBe(unexpectedVariable1);
+    });
+
+    test('String value', function () {
+        const aDUnexpectedVariable2 = ArrayDelete(unexpectedVariable2, 0);
+        expect(aDUnexpectedVariable2).toBe(unexpectedVariable2);
+    });
+
+    test('Object value', function () {
+        const aDUnexpectedVariable3 = ArrayDelete(unexpectedVariable3, 0);
+        expect(aDUnexpectedVariable3).toBe(unexpectedVariable3);
+    });
+
+    test('Non-array variable and undefined index', function () {
+        const aDUnexpectedVariable3 = ArrayDelete(unexpectedVariable3);
+        expect(aDUnexpectedVariable3).toBe(unexpectedVariable3);
+    });
+});
+
+describe('Deleting Array item', function () {
+    const array1 = [1, 'hello', true, '2', 'world'];
+    const indexToDelete = 1;
+    const itemToDelete = array1[indexToDelete];
+    
+    const aDUArray1 = ArrayDelete(array1, indexToDelete);
+
+    test('Delete an item of the array and compare the original array', function () {
+        expect(aDUArray1).not.toEqual(array1);
+    });
+
+    test('Delete an item of the array and compare if the deleted value is there', function () {
+        expect(aDUArray1).not.toEqual(expect.arrayContaining([itemToDelete]));
+    });
+    
+    test('Delete an item of the array and compare the arrays lengths', function () {
+        expect(aDUArray1.length).toBe(array1.length - 1);
+    });
+
+    test('Array variable and undefined index', function () {
+        const aDUArray1 = ArrayDelete(array1);
+        expect(aDUArray1).toBe(array1);
+    });
+});

package/test/general/array/flattenDeep.test.js

@@ -0,0 +1,44 @@
+const { flattenDeep } = require('../../../dist/cjs');
+
+describe('Flatting the Array', function () {
+    const array1 = [1, 'hello', true, '2', 'world'];
+    const array2 = [1, 'hello', true, '2', undefined, 'world'];
+    const array3 = [{name: 'Jose', lastName: 'Gonzalez'}, 'hello', 'world', [{ compraId: '1' }, { compraId: 2 }, [1, 2, [3, 4]]]];
+    const array4 = [{name: 'Jose'}, {name: 'David'}, {name: 'Eduardo'}];
+    const array5 = [1, [[[2]], 3, [4, 5, [6, 7, 8], 9], [[[10, 11]], 12]]];
+
+    test('Undefined array', function () {
+        const undefinedVariable = flattenDeep(undefined);
+        expect([]).toEqual(undefinedVariable);
+    });
+
+    test('Non-array type', function () {
+        const objectVariable = flattenDeep({no: 'array'});
+        expect(undefined).toEqual(objectVariable);
+    });
+
+    test('1-level array with primitive data type', function () {
+        const flattenedArray = flattenDeep(array1);
+        expect(array1).toEqual(flattenedArray)
+    });
+
+    test('1-level array including undefined items', function () {
+        const flattenedArray = flattenDeep(array2);
+        expect(array2).toEqual(flattenedArray)
+    });
+
+    test('n-level array', function () {
+        const flattenedArray = flattenDeep(array3);
+        expect([{ "name": "Jose", "lastName": "Gonzalez"}, "hello", "world", { "compraId": "1" }, { "compraId": 2 }, 1, 2, 3, 4]).toEqual(flattenedArray);
+    });
+
+    test('Just an object array', function () {
+        const flattenedArray = flattenDeep(array4);
+        expect(array4).toEqual(flattenedArray);
+    });
+
+    test('Definitive test', function () {
+        const flattenedArray = flattenDeep(array5);
+        expect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]).toEqual(flattenedArray);
+    });
+});

package/test/general/array/getFirstIndexFromArray.test.js

@@ -0,0 +1,56 @@
+const { getFirstIndexFromArray } = require('../../../dist/cjs');
+
+const array1 = [{ name: 'jose', age: 30 }, { name: 'david', age: 30}, { name: 'eduardo', age: 29 }];
+const array1Callback = (item) => item.age === 30;
+
+const array2 = [0, 1, 2, 2, 3, 4, 4, 4, 5];
+const array2Callback = (item) => item === 4;
+
+describe('Get the -1 index', function () {
+    const expectedIndex = -1;
+    const array1CallbackNoMatch =  (item) => item.age === 31;
+    
+    test('Undefined arguments', function () {
+        const index = getFirstIndexFromArray();
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('non-undefined first argument', function () {
+        const index = getFirstIndexFromArray(array1);
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('non-undefined second argument', function () {
+        const index1 = getFirstIndexFromArray(undefined, array1Callback);
+        const index2 = getFirstIndexFromArray([], array1Callback);
+        expect(expectedIndex).toEqual(index1);
+        expect(expectedIndex).toEqual(index2);
+    });
+
+    test('Different type first argument', function () {
+        const index = getFirstIndexFromArray(1, array1Callback);
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('Different type second argument', function () {
+        const index = getFirstIndexFromArray(array1, 'Hello World');
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('Regular scenario, no records to match', function () {
+        const index = getFirstIndexFromArray(array1, array1CallbackNoMatch);
+        expect(expectedIndex).toEqual(index);
+    });
+});
+
+describe('Regular scenario', function () {
+    test('Regular scenario', function () {
+        const index = getFirstIndexFromArray(array1, array1Callback);
+        expect(0).toEqual(index);
+    });
+
+    test('Regular scenario with primitive types', function () {
+        const index = getFirstIndexFromArray(array2, array2Callback);
+        expect(5).toEqual(index);
+    });
+});

package/test/general/array/getLastIndexFromArray.test.js

@@ -0,0 +1,56 @@
+const { getLastIndexFromArray } = require('../../../dist/cjs');
+
+const array1 = [{ name: 'jose', age: 30 }, { name: 'david', age: 30}, { name: 'eduardo', age: 29 }];
+const array1Callback = (item) => item.age === 30;
+
+const array2 = [0, 1, 2, 2, 3, 4, 4, 4, 5];
+const array2Callback = (item) => item === 4;
+
+describe('Get the -1 index', function () {
+    const expectedIndex = -1;
+    const array1CallbackNoMatch =  (item) => item.age === 31;
+    
+    test('Undefined arguments', function () {
+        const index = getLastIndexFromArray();
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('non-undefined first argument', function () {
+        const index = getLastIndexFromArray(array1);
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('non-undefined second argument', function () {
+        const index1 = getLastIndexFromArray(undefined, array1Callback);
+        const index2 = getLastIndexFromArray([], array1Callback);
+        expect(expectedIndex).toEqual(index1);
+        expect(expectedIndex).toEqual(index2);
+    });
+
+    test('Different type first argument', function () {
+        const index = getLastIndexFromArray(1, array1Callback);
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('Different type second argument', function () {
+        const index = getLastIndexFromArray(array1, 'Hello World');
+        expect(expectedIndex).toEqual(index);
+    });
+
+    test('Regular scenario, no records to match', function () {
+        const index = getLastIndexFromArray(array1, array1CallbackNoMatch);
+        expect(expectedIndex).toEqual(index);
+    });
+});
+
+describe('Regular scenario', function () {
+    test('Regular scenario with objects', function () {
+        const index = getLastIndexFromArray(array1, array1Callback);
+        expect(1).toEqual(index);
+    });
+
+    test('Regular scenario with primitive types', function () {
+        const index = getLastIndexFromArray(array2, array2Callback);
+        expect(7).toEqual(index);
+    });
+});

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

@@ -0,0 +1,144 @@
+const { isEmpty } = require('../../../dist/cjs');
+
+describe('Validating the emptyness of the given argument', function () {
+    const empty1 = undefined;
+    const empty2 = null;
+    const empty3 = '';
+    const empty4 = [];
+    const empty5 = {};    
+
+    test('Undefined', function () {
+        const empty = isEmpty(empty1);
+        expect(true).toEqual(empty);
+    });
+
+    test('Null type', function () {
+        const empty = isEmpty(empty2);
+        expect(true).toEqual(empty);
+    });
+
+    test('Empty string', function () {
+        const empty = isEmpty(empty3);
+        expect(true).toEqual(empty);
+    });
+
+    test('Array without items', function () {
+        const empty = isEmpty(empty4);
+        expect(true).toEqual(empty);
+    });
+
+    test('Object wihtout properties', function () {
+        const empty = isEmpty(empty5);
+        expect(true).toEqual(empty);
+    });
+});
+
+describe('Validating falsy arguments', function () {
+    const falsyEmpty1 = 0;
+    const falsyEmpty2 = 0.0;
+    const falsyEmpty3 = -0;
+    const falsyEmpty4 = NaN;
+
+    const falsyEmpty5 = true;
+    const falsyEmpty6 = false;
+    
+    test('Zero number', function () {
+        const empty = isEmpty(falsyEmpty1);
+        expect(false).toEqual(empty);
+    });
+
+    test('Zero number with Falsy', function () {
+        const empty = isEmpty(falsyEmpty1, true);
+        expect(true).toEqual(empty);
+    });
+
+    test('Zero floating number', function () {
+        const empty = isEmpty(falsyEmpty2);
+        expect(false).toEqual(empty);
+    });
+
+    test('Zero floating number with Falsy', function () {
+        const empty = isEmpty(falsyEmpty2, true);
+        expect(true).toEqual(empty);
+    });
+
+    test('Negative Zero number', function () {
+        const empty = isEmpty(falsyEmpty3);
+        expect(false).toEqual(empty);
+    });
+
+    test('Negative Zero number with Falsy', function () {
+        const empty = isEmpty(falsyEmpty3, true);
+        expect(true).toEqual(empty);
+    });
+
+    test('NaN', function () {
+        const empty = isEmpty(falsyEmpty4);
+        expect(false).toEqual(empty);
+    });
+
+    test('NaN with Falsy', function () {
+        const empty = isEmpty(falsyEmpty4, true);
+        expect(true).toEqual(empty);
+    });
+
+
+    test('Affirmative Boolean', function () {
+        const empty = isEmpty(falsyEmpty5);
+        expect(false).toEqual(empty);
+    });
+
+    test('Affirmative Boolean with Falsy', function () {
+        const empty = isEmpty(falsyEmpty5, true);
+        expect(false).toEqual(empty);
+    });
+
+    test('Negative Boolean', function () {
+        const empty = isEmpty(falsyEmpty6);
+        expect(false).toEqual(empty);
+    });
+
+    test('Negative Boolean with Falsy', function () {
+        const empty = isEmpty(falsyEmpty6, true);
+        expect(true).toEqual(empty);
+    });
+});
+
+describe('Validating non-empty arguments', function () {
+    const notEmpty1 = 'Hello World';
+    const notEmpty2 = ['Hello', 'World'];
+    const notEmpty3 = { tag1: 'Hello', tag2: 'World' };
+    const notEmpty4 = 1;
+    const notEmpty5 = "0";
+    const notEmpty6 = (dig1 = 1, dig2 = 2) => dig1 + dig2; 
+
+    test('String type', function () {
+        const empty = isEmpty(notEmpty1);
+        expect(false).toEqual(empty);
+    });
+
+    test('Array type', function () {
+        const empty = isEmpty(notEmpty2);
+        expect(false).toEqual(empty);
+    });
+
+    test('Object type', function () {
+        const empty = isEmpty(notEmpty3);
+        expect(false).toEqual(empty);
+    });
+
+    test('Number different to zero', function () {
+        const empty = isEmpty(notEmpty4);
+        expect(false).toEqual(empty);
+    });
+
+    test('Zero Number in string', function () {
+        const empty = isEmpty(notEmpty5);
+        expect(false).toEqual(empty);
+    });
+
+    test('Function type', function () {
+        const empty = isEmpty(notEmpty6);
+        expect(false).toEqual(empty);
+    });
+});

package/test/general/object/cloneDeep.test.js

@@ -0,0 +1,152 @@
+const { cloneDeep, isEmpty, _hasProperty } = require('../../../dist/cjs');
+
+describe('Returning an undefined with empty variables', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+
+    test('Undefined variable', function () {
+        const empty = cloneDeep(empty1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Array variable', function () {
+        const empty = cloneDeep(empty2);
+        expect(empty).toStrictEqual([]);
+    });
+
+    test('Empty Object variable', function () {
+        const empty = cloneDeep(empty3);
+        expect(empty).toStrictEqual({});
+    });
+
+});
+
+describe('No new references with primitive variables', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+
+    test('String variable', function () {
+        const cDVariable1 = cloneDeep(variable1);
+        expect(cDVariable1).toStrictEqual(variable1);
+    });
+
+    test('Numeric variable', function () {
+        const cDVariable2 = cloneDeep(variable2);
+        expect(cDVariable2).toStrictEqual(variable2);
+    }); 
+
+    test('Boolean variable', function () {
+        const cDVariable3 = cloneDeep(variable3);
+        expect(cDVariable3).toStrictEqual(variable3);
+    });
+});
+
+
+describe('Creating an new reference by object/array variables', function () {
+    const spanishSalutation = 'Hola';
+    const variable1 = ['Hello', 'World'];
+    const variable2 = { tag1: 'Hello', tag2: 'World' };
+    const variable3 = [{ tag1: 'Hello1', tag2: 'World1' }, { tag1: 'Hello2', tag2: 'World2' }];
+
+    const cDVariable1 = cloneDeep(variable1);
+    const cDVariable2 = cloneDeep(variable2);
+    const cDVariable3 = cloneDeep(variable3);
+
+    test('Compare the arrays as object instances', function () {
+        expect(cDVariable1).not.toBe(variable1);
+    });
+
+    test('Compare the arrays values', function () {
+        expect(cDVariable1).toEqual(variable1);
+    });
+
+    test('Edit a cloned array value and compare' , function () {
+        cDVariable1[0] = spanishSalutation;
+        expect(cDVariable1).not.toEqual(variable1);
+    });
+
+    test('Compare the objects as object instances' , function () {
+        expect(cDVariable2).not.toBe(variable2);
+    });
+
+    test('Compare the object properties', function () {
+        expect(cDVariable2).toEqual(variable2);
+    });
+
+    test('Edit a cloned object property and compare' , function () {
+        cDVariable2.tag1 = spanishSalutation;
+        expect(cDVariable2).not.toEqual(variable2);
+    });
+
+    test('Compare the object-item arrays as object instances' , function () {
+        expect(cDVariable3).not.toBe(variable3);
+    });
+
+    test('Compare the arrays object-items', function () {
+        expect(cDVariable3).toEqual(variable3);
+    });
+
+    test('Edit a cloned object-item array property and compare' , function () {
+        cDVariable3[0].tag1 = spanishSalutation;
+        expect(cDVariable3).not.toEqual(variable3);
+    });
+});
+
+describe('Problems creating a new object reference with inner objects and functions', function () {
+    const variable1 = Number;
+    const variable2 = NaN;
+    const variable3 = Infinity;
+    const variable4 = new Date('12/01/1991');
+    const variable5 = undefined;
+    const variable6 = (dig1 = 1, dig2 = 2) => dig1 + dig2;
+    const object1 = { a: variable1, b: variable2, c: variable3, d: variable4, e: variable5, f: variable6 };
+
+    test('Number-constructor variable', function () {
+        const cDVariable1 = cloneDeep(variable1);
+        expect(cDVariable1).toStrictEqual(variable1);
+    });
+
+    test('NaN variable', function () {
+        const cDVariable2 = cloneDeep(variable2);
+        expect(cDVariable2).toStrictEqual(variable2);
+    });
+
+    test('Infinity variable', function () {
+        const cDVariable3 = cloneDeep(variable3);
+        expect(cDVariable3).toStrictEqual(variable3);
+    });
+
+    test('Date variable', function () {
+        const cDVariable4 = cloneDeep(variable4);
+        expect(cDVariable4).toBe(variable4.toISOString());
+    });
+
+    test('Function variable', function () {
+        const cDVariable6 = cloneDeep(variable6);
+        expect(cDVariable6).toStrictEqual(variable6);
+    });
+
+    test('An object with inner objects', function () {
+        const cDObject1 = cloneDeep(object1);
+
+        const emptyA = _hasProperty(cDObject1, 'a');
+        const emptyB = isEmpty(cDObject1.b);
+        const emptyC = isEmpty(cDObject1.c);
+        const emptyD1 = cDObject1.d instanceof Date;
+        const emptyD2 = Date.parse(cDObject1.d);
+        const emptyE = isEmpty(cDObject1.e);
+        const emptyF = isEmpty(cDObject1.f);
+
+        expect(emptyA).toBeFalsy();
+        expect(emptyB).toBeTruthy();
+        expect(emptyC).toBeTruthy();
+        expect(emptyD1).toBeFalsy();
+        expect(emptyD2).toBeTruthy();
+        expect(emptyE).toBeTruthy();
+        expect(emptyF).toBeTruthy();
+
+        expect(cDObject1).not.toEqual(object1);
+    });
+});