@qrvey/utils 1.1.2 → 1.1.6

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

@@ -1,4 +1,4 @@
-const { cloneDeep, isEmpty, _hasProperty } = require('../../../dist/cjs');
+const { cloneDeep } = require('../../../dist/cjs');
 
 describe('Returning an undefined with empty variables', function () {
     const empty1 = undefined;
@@ -131,21 +131,13 @@ describe('Problems creating a new object reference with inner objects and functi
     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.toHaveProperty('a');
+        expect(cDObject1.b).toBeNull();
+        expect(cDObject1.c).toBeNull();
+        expect(cDObject1.d instanceof Date).toBeFalsy();
+        expect(Date.parse(cDObject1.d)).toBe(Date.parse(object1.d));
+        expect(cDObject1.e).toBeUndefined();
+        expect(cDObject1.f).toBeUndefined();
 
         expect(cDObject1).not.toEqual(object1);
     });

package/test/general/object/getAttribute.test.js

@@ -0,0 +1,316 @@
+const { getAttribute } = require('../../../dist/cjs');
+
+const obj = {
+    api_key: "2Wo1LiLW4uiAiJ9FU6BphNEjxTqQNc5aPhCnpkL6",
+    customTokens: { sample: Array(2) },
+    LoadStyles: false,
+    appid: "D_64XzSNz",
+    domain: "https://postdev1.qrveyapp.com",
+    QRVEYID: "5LtRi43_qt",
+};
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = null;
+    const empty3 = [];
+    const empty4 = {};
+    const empty5 = '';
+
+    test('No arguments', function () {
+        const empty = getAttribute();
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined variable', function () {
+        const empty = getAttribute(empty1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Null variable', function () {
+        const empty = getAttribute(empty2);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Array variable', function () {
+        const empty = getAttribute(empty3);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Object variable', function () {
+        const empty = getAttribute(empty4);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty String variable', function () {
+        const empty = getAttribute(empty5);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined variable with Key', function () {
+        const empty = getAttribute(empty1, 'appid');
+        expect(empty).toBeUndefined();
+    });
+
+    test('Null variable with Key', function () {
+        const empty = getAttribute(empty2, 'appid');
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Array variable with Key', function () {
+        const empty = getAttribute(empty3, 'appid');
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Object variable with Key', function () {
+        const empty = getAttribute(empty4, 'appid');
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty String variable with Key', function () {
+        const empty = getAttribute(empty5, 'appid');
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined key argument', function () {
+        const empty = getAttribute(obj, empty1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty key argument', function () {
+        const empty = getAttribute(obj, empty5);
+        expect(empty).toBeUndefined();
+    });
+});
+
+describe('Testing with different argument type', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+    const variable4 = new Date();
+
+    test('String variable', function () {
+        const empty = getAttribute(variable1, variable1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Numeric variable', function () {
+        const empty = getAttribute(variable2, variable1);
+        expect(empty).toBeUndefined();
+    }); 
+
+    test('Boolean variable', function () {
+        const empty = getAttribute(variable3, variable1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Date variable', function () {
+        const empty = getAttribute(variable4, variable1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Numeric-type key', function () {
+        const empty = getAttribute(obj, variable2);
+        expect(empty).toBeUndefined();
+    });
+
+    test('boolean-type key', function () {
+        const empty = getAttribute(obj, variable3);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Date-type key', function () {
+        const empty = getAttribute(obj, variable4);
+        expect(empty).toBeUndefined();
+    });
+});
+
+
+describe('Retrieving attribute by key', function () {
+    const lowerAttribute1 = 'app_id';
+    const lowerAttribute2 = 'appId';
+    const lowerAttribute3 = 'appid';
+    const lowerAttribute4 = 'AppId';
+    const lowerAttribute5 = 'APPID';
+
+    const snakeAttribute1 = 'api_key';
+    const snakeAttribute2 = 'apiKey';
+    const snakeAttribute3 = 'apikey';
+    const snakeAttribute4 = 'ApiKey';
+    const snakeAttribute5 = 'APIKEY';
+
+    const upperAttribute1 = 'qrvey_id';
+    const upperAttribute2 = 'qrveyId';
+    const upperAttribute3 = 'qrveyid';
+    const upperAttribute4 = 'QrveyId';
+    const upperAttribute5 = 'QRVEYID';
+
+    const camelAttribute1 = 'custom_tokens';
+    const camelAttribute2 = 'customTokens';
+    const camelAttribute3 = 'customtokens';
+    const camelAttribute4 = 'CustomTokens';
+    const camelAttribute5 = 'CUSTOMTOKENS';
+
+    const pascalAttribute1 = 'load_styles';
+    const pascalAttribute2 = 'loadStyles';
+    const pascalAttribute3 = 'loadstyles';
+    const pascalAttribute4 = 'LoadStyles';
+    const pascalAttribute5 = 'LOADSTYLES';
+    
+
+    test('Lower attribute with snake_case key', function () {
+        const attribute = getAttribute(obj, lowerAttribute1);
+        expect(attribute).toEqual(obj[lowerAttribute3]);
+    });
+
+    test('Lower attribute with camelCase key', function () {
+        const attribute = getAttribute(obj, lowerAttribute2);
+        expect(attribute).toEqual(obj[lowerAttribute3]);
+    });
+
+    test('Lower attribute with lowercase key', function () {
+        const attribute = getAttribute(obj, lowerAttribute3);
+        expect(attribute).toEqual(obj[lowerAttribute3]);
+    });
+
+    test('Lower attribute with PascalCase key', function () {
+        const attribute = getAttribute(obj, lowerAttribute4);
+        expect(attribute).toEqual(obj[lowerAttribute3]);
+    });
+
+    test('Lower attribute with UPPERCASE key', function () {
+        const attribute = getAttribute(obj, lowerAttribute5);
+        expect(attribute).toEqual(obj[lowerAttribute3]);
+    });
+
+
+    test('Snake attribute with snake_case key', function () {
+        const attribute = getAttribute(obj, snakeAttribute1);
+        expect(attribute).toEqual(obj[snakeAttribute1]);
+    });
+
+    test('Snake attribute with camelCase key', function () {
+        const attribute = getAttribute(obj, snakeAttribute2);
+        expect(attribute).toEqual(obj[snakeAttribute1]);
+    });
+
+    test('Snake attribute with PascalCase key', function () {
+        const attribute = getAttribute(obj, snakeAttribute4);
+        expect(attribute).toEqual(obj[snakeAttribute1]);
+    });
+
+
+    test('Upper attribute with snake_case key', function () {
+        const attribute = getAttribute(obj, upperAttribute1);
+        expect(attribute).toEqual(obj[upperAttribute5]);
+    });
+
+    test('Upper attribute with camelCase key', function () {
+        const attribute = getAttribute(obj, upperAttribute2);
+        expect(attribute).toEqual(obj[upperAttribute5]);
+    });
+
+    test('Upper attribute with lowercase key', function () {
+        const attribute = getAttribute(obj, upperAttribute3);
+        expect(attribute).toEqual(obj[upperAttribute5]);
+    });
+
+    test('Upper attribute with PascalCase key', function () {
+        const attribute = getAttribute(obj, upperAttribute4);
+        expect(attribute).toEqual(obj[upperAttribute5]);
+    });
+
+    test('Upper attribute with UPPERCASE key', function () {
+        const attribute = getAttribute(obj, upperAttribute5);
+        expect(attribute).toEqual(obj[upperAttribute5]);
+    });
+
+
+    test('Camel attribute with snake_case key', function () {
+        const attribute = getAttribute(obj, camelAttribute1);
+        expect(attribute).toEqual(obj[camelAttribute2]);
+    });
+
+    test('Camel attribute with camelCase key', function () {
+        const attribute = getAttribute(obj, camelAttribute2);
+        expect(attribute).toEqual(obj[camelAttribute2]);
+    });
+
+    test('Camel attribute with PascalCase key', function () {
+        const attribute = getAttribute(obj, camelAttribute4);
+        expect(attribute).toEqual(obj[camelAttribute2]);
+    });
+
+
+    test('Pascal attribute with snake_case key', function () {
+        const attribute = getAttribute(obj, pascalAttribute1);
+        expect(attribute).toEqual(obj[pascalAttribute4]);
+    });
+
+    test('Pascal attribute with camelCase key', function () {
+        const attribute = getAttribute(obj, pascalAttribute2);
+        expect(attribute).toEqual(obj[pascalAttribute4]);
+    });
+
+    test('Pascal attribute with PascalCase key', function () {
+        const attribute = getAttribute(obj, pascalAttribute4);
+        expect(attribute).toEqual(obj[pascalAttribute4]);
+    });
+});
+
+describe('No-match Keys', function() {
+    const noCaseKey1 = 'customTokenS';
+    const noCaseKey2 = 'loadstyles';
+    const noCaseKey3 = 'api_KEY';
+
+    const key4 = 'apikey';
+    const key5 = 'APIKEY'
+    const key6 = 'customtokens';
+    const key7 = 'CUSTOMTOKENS';
+    const key8 = 'loadstyles';
+    const key9 = 'LOADSTYLES';
+
+    test('No match #1', function () {
+        const empty = getAttribute(obj, noCaseKey1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('No match #2', function () {
+        const empty = getAttribute(obj, noCaseKey2);
+        expect(empty).toBeUndefined();
+    });
+
+    test('No match #3', function () {
+        const empty = getAttribute(obj, noCaseKey3);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Snake attribute with lowercase key', function () {
+        const attribute = getAttribute(obj, key4);
+        expect(attribute).toBeUndefined();
+    });
+
+    test('Snake attribute with UPPERCASE key', function () {
+        const attribute = getAttribute(obj, key5);
+        expect(attribute).toBeUndefined();
+    });
+
+    test('Camel attribute with lowercase key', function () {
+        const attribute = getAttribute(obj, key6);
+        expect(attribute).toBeUndefined();
+    });
+
+    test('Camel attribute with UPPERCASE key', function () {
+        const attribute = getAttribute(obj, key7);
+        expect(attribute).toBeUndefined();
+    });
+
+    test('Pascal attribute with lowercase key', function () {
+        const attribute = getAttribute(obj, key8);
+        expect(attribute).toBeUndefined();
+    });
+
+    test('Pascal attribute with UPPERCASE key', function () {
+        const attribute = getAttribute(obj, key9);
+        expect(attribute).toBeUndefined();
+    });
+});

package/test/general/object/hasProperty.test.js

@@ -0,0 +1,103 @@
+const { _hasProperty } = require('../../../dist/cjs');
+
+const obj = {
+    api_key: "2Wo1LiLW4uiAiJ9FU6BphNEjxTqQNc5aPhCnpkL6",
+    custom_tokens: { sample: Array(2) },
+    load_styles: false,
+    app_id: "D_64XzSNz",
+    domain: "https://postdev1.qrveyapp.com",
+    qrvey_id: "5LtRi43_qt",
+};
+
+const arr = [{ tag1: 'Hello', tag2: 'World' }];
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = null;
+    const empty3 = {};
+
+    test('No arguments', function () {
+        const hasProperty = _hasProperty();
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Undefined first argument', function () {
+        const hasProperty = _hasProperty(empty1);
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Null first argument with filled second argument', function () {
+        const hasProperty = _hasProperty(empty2, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Empty object with filled second argument', function () {
+        const hasProperty = _hasProperty(empty3, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    });
+});
+
+describe('Testing with different argument type', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+    const variable4 = new Date();
+
+    test('String variable', function () {
+        const hasProperty = _hasProperty(variable1, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Numeric variable', function () {
+        const hasProperty = _hasProperty(variable2, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    }); 
+
+    test('Boolean variable', function () {
+        const hasProperty = _hasProperty(variable3, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Date variable', function () {
+        const hasProperty = _hasProperty(variable4, 'api_key');
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Numeric-type key', function () {
+        const hasProperty = _hasProperty(obj, variable2);
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('boolean-type key', function () {
+        const hasProperty = _hasProperty(obj, variable3);
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Date-type key', function () {
+        const hasProperty = _hasProperty(obj, variable4);
+        expect(hasProperty).toBeFalsy();
+    });
+
+    test('Array-type key', function () {
+        const hasProperty = _hasProperty(obj, arr);
+        expect(hasProperty).toBeFalsy();
+    });
+});
+
+
+describe('Matching a property with the attribute', function () {
+    test('Object', function () {
+        const hasProperty = _hasProperty(obj, 'api_key');
+        expect(hasProperty).toBeTruthy();
+    });
+
+    test('Array', function () {
+        const hasProperty = _hasProperty(arr, '0');
+        expect(hasProperty).toBeTruthy();
+    });
+
+    test('Not matching', function () {
+        const hasProperty = _hasProperty(obj, 'apikey');
+        expect(hasProperty).toBeFalsy();
+    });
+});

package/test/general/object/objectCopy.test.js

@@ -0,0 +1,105 @@
+const { objectCopy } = require('../../../dist/cjs');
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+
+    test('No arguments', function () {
+        const empty = objectCopy();
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined variable', function () {
+        const empty = objectCopy(empty1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Empty Array variable', function () {
+        const empty = objectCopy(empty2);
+        expect(empty).toStrictEqual(empty2);
+    });
+
+    test('Empty Object variable', function () {
+        const empty = objectCopy(empty3);
+        expect(empty).toStrictEqual(empty3);
+    });
+});
+
+describe('Testing with different argument type', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+
+    test('String variable', function () {
+        const cDVariable1 = objectCopy(variable1);
+        expect(cDVariable1).toBe(variable1);
+    });
+
+    test('Numeric variable', function () {
+        const cDVariable2 = objectCopy(variable2);
+        expect(cDVariable2).toBe(variable2);
+    }); 
+
+    test('Boolean variable', function () {
+        const cDVariable3 = objectCopy(variable3);
+        expect(cDVariable3).toBe(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 variable4 = new Date('2021-10-01');
+
+    const cDVariable1 = objectCopy(variable1);
+    const cDVariable2 = objectCopy(variable2);
+    const cDVariable3 = objectCopy(variable3);
+    const cDVariable4 = objectCopy(variable4);
+
+    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 comparing it' , 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 comparing it' , 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 comparing it' , function () {
+        cDVariable3[0].tag1 = spanishSalutation;
+        expect(cDVariable3).not.toEqual(variable3);
+    });
+
+    test('Cloning Date variable and comparing it' , function () {
+        expect(cDVariable4).not.toEqual(variable4);
+    });
+});

package/test/general/string/capitalize.test.js

@@ -0,0 +1,87 @@
+const { capitalize } = require('../../../dist/cjs');
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+    const empty4 = '';
+    const empty5 = null;
+
+    test('No arguments', function () {
+        const text = capitalize();
+        expect(text).toBe("");
+    });
+
+    test('Undefined variable', function () {
+        const text = capitalize(empty1);
+        expect(text).toBe("");
+    });
+
+    test('Empty Array variable', function () {
+        const text = capitalize(empty2);
+        expect(text).toBe(empty2);
+    });
+
+    test('Empty Object variable', function () {
+        const text = capitalize(empty3);
+        expect(text).toBe(empty3);
+    });
+
+    test('Empty String variable', function () {
+        const text = capitalize(empty4);
+        expect(text).toBe(empty4);
+    });
+
+    test('Null variable', function () {
+        const text = capitalize(empty5);
+        expect(text).toBe(empty5);
+    });
+});
+
+describe('Testing differente types', function () {
+    const variable1 = 1;
+    const variable2 = false;
+    const variable3 = new Date();
+    const variable4 = dig1 => dig1;
+
+    test('Numeric type', function () {
+        const text = capitalize(variable1);
+        expect(text).toBe(variable1);
+    });
+
+    test('Boolean type', function () {
+        const text = capitalize(variable2);
+        expect(text).toBe(variable2);
+    });
+
+    test('Date type', function () {
+        const text = capitalize(variable3);
+        expect(text).toBe(variable3);
+    });
+
+    test('Function type', function () {
+        const text = capitalize(variable4);
+        expect(text).toBe(variable4);
+    });
+});
+
+describe('Common scenarios', function () {
+    const variable1 = "hello world";
+    const variable2 = "hOLA MUNDO";
+    const variable3 = 'HELLO THERE';
+
+    test('Scenario #1', function () {
+        const text = capitalize(variable1);
+        expect(text).toBe("Hello world");
+    });
+
+    test('Scenario #2', function () {
+        const text = capitalize(variable2);
+        expect(text).toBe("Hola mundo");
+    });
+
+    test('Scenario #3', function () {
+        const text = capitalize(variable3);
+        expect(text).toBe("Hello there");
+    });
+});