@qrvey/utils 1.1.8 → 1.2.1

package/test/columns/isComplexColumn.test.js

@@ -0,0 +1,162 @@
+const { COMPLEX_COLUMN, COLUMN, isComplexColumn } = require("../../dist/cjs");
+
+const column1 = {
+    id: '123',
+    qrveyid: 'abc',
+    type: COMPLEX_COLUMN.EXPRESSION
+};
+
+const column2 = {
+    id: '789',
+    qrveyid: 'hgij',
+    type: COMPLEX_COLUMN.FILEUPLOAD
+};
+
+const column3 = {
+    id: '789',
+    qrveyid: 'def',
+    type: COMPLEX_COLUMN.IMAGEUPLOAD
+};
+
+const column4 = {
+    id: '789',
+    qrveyid: 'def',
+    type: COMPLEX_COLUMN.LONGTEXT
+};
+
+const column5 = {
+    id: '789',
+    qrveyid: 'def',
+    type: COMPLEX_COLUMN.TEXTFIELD
+};
+
+// Different column type
+const wrongColumn1 = {
+    id: '456',
+    qrveyid: 'yn',
+    type: COLUMN.YES_NO
+};
+
+// Different column type
+const wrongColumn2 = {
+    id: '789',
+    qrveyid: 'ZZZ',
+    type: COLUMN.TEXT_LABEL
+};
+
+describe('Testing undefined/empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = null;
+    const empty3 = '';
+    const empty4 = [];
+    const empty5 = {};
+
+    test('no argument passed', function () {
+        const validation = isComplexColumn();
+        expect(validation).toBeFalsy();
+    });
+
+    test('Undefined argument', function () {
+        const validation = isComplexColumn(empty1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Null argument', function () {
+        const validation = isComplexColumn(empty2);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty string argument', function () {
+        const validation = isComplexColumn(empty3);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty array argument', function () {
+        const validation = isComplexColumn(empty4);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty object argument', function () {
+        const validation = isComplexColumn(empty5);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Testing no-object arguments', function () {
+    const variable1 = 1;
+    const variable2 = false;
+    const variable3 = new Date();
+    const variable4 = ['Hello', 'World'];
+    const variable5 = (num1 = 1, num2 = 2) => num1 + num2;
+
+    test('Numeric variable', function () {
+        const validation = isComplexColumn(variable1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Boolean variable', function () {
+        const validation = isComplexColumn(variable2);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Date object variable', function () {
+        const validation = isComplexColumn(variable3);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Array variable', function () {
+        const validation = isComplexColumn(variable4);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Function-like variable', function () {
+        const validation = isComplexColumn(variable5);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Testing invalid expected object', function () {
+    const variable1 = { tag1: 'value1', tag2: 'value2' };
+    
+    test('Different expected object', function () {
+        const validation = isComplexColumn(variable1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Formula Column type with different formula type', function () {
+        const validation = isComplexColumn(wrongColumn1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Missing formulaType for formula column type', function () {
+        const validation = isComplexColumn(wrongColumn2);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Regular scenarios', function () {
+    test('Scenario #1', function () {
+        const validation = isComplexColumn(column1);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Scenario #2', function () {
+        const validation = isComplexColumn(column2);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Scenario #3', function () {
+        const validation = isComplexColumn(column3);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Scenario #4', function () {
+        const validation = isComplexColumn(column4);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Scenario #5', function () {
+        const validation = isComplexColumn(column5);
+        expect(validation).toBeTruthy();
+    });
+});

package/test/columns/isDateColumn.test.js

@@ -0,0 +1,145 @@
+const { COLUMN, FORMULA, isDateColumn } = require("../../dist/cjs");
+
+const column1 = {
+    formulaid: '123',
+    formulaType: FORMULA.DATE,
+    id: '123',
+    qrveyid: 'abc',
+    type: COLUMN.FORMULA
+};
+
+const column2 = {
+    id: '789',
+    qrveyid: 'abc',
+    type: COLUMN.DATE
+};
+
+const column3 = {
+    formulaType: FORMULA.DATE,
+    id: '789',
+    qrveyid: 'abc',
+    type: COLUMN.DATE
+};
+
+// Formula Column type with different formula type
+const wrongColumn1 = {
+    formulaid: '456',
+    formulaType: FORMULA.NUMBER,
+    id: '456',
+    qrveyid: 'abc',
+    type: COLUMN.FORMULA
+};
+
+// Missing formulaType for column type
+const wrongColumn2 = {
+    id: '789',
+    qrveyid: 'abc',
+    type: COLUMN.FORMULA
+};
+
+describe('Testing undefined/empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = null;
+    const empty3 = '';
+    const empty4 = [];
+    const empty5 = {};
+
+    test('no argument passed', function () {
+        const validation = isDateColumn();
+        expect(validation).toBeFalsy();
+    });
+
+    test('Undefined argument', function () {
+        const validation = isDateColumn(empty1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Null argument', function () {
+        const validation = isDateColumn(empty2);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty string argument', function () {
+        const validation = isDateColumn(empty3);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty array argument', function () {
+        const validation = isDateColumn(empty4);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Empty object argument', function () {
+        const validation = isDateColumn(empty5);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Testing no-object arguments', function () {
+    const variable1 = 1;
+    const variable2 = false;
+    const variable3 = new Date();
+    const variable4 = ['Hello', 'World'];
+    const variable5 = (num1 = 1, num2 = 2) => num1 + num2;
+
+    test('Numeric variable', function () {
+        const validation = isDateColumn(variable1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Boolean variable', function () {
+        const validation = isDateColumn(variable2);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Date object variable', function () {
+        const validation = isDateColumn(variable3);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Array variable', function () {
+        const validation = isDateColumn(variable4);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Function-like variable', function () {
+        const validation = isDateColumn(variable5);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Testing invalid expected object', function () {
+    const variable1 = { tag1: 'value1', tag2: 'value2' };
+    
+    test('Different expected object', function () {
+        const validation = isDateColumn(variable1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Formula Column type with different formula type', function () {
+        const validation = isDateColumn(wrongColumn1);
+        expect(validation).toBeFalsy();
+    });
+
+    test('Missing formulaType for formula column type', function () {
+        const validation = isDateColumn(wrongColumn2);
+        expect(validation).toBeFalsy();
+    });
+});
+
+describe('Regular scenarios', function () {
+    test('Scenario #1', function () {
+        const validation = isDateColumn(column1);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Scenario #2', function () {
+        const validation = isDateColumn(column2);
+        expect(validation).toBeTruthy();
+    });
+
+    test('Date column type but setting formula type', function () {
+        const validation = isDateColumn(column3);
+        expect(validation).toBeTruthy();
+    });
+});

package/test/format.test.js

@@ -65,7 +65,7 @@ describe('Testing format util', function () {
 
     test("Format Number Abbreviated", ()=>{
         const numberFormasted = formatAbbreviated(4.419, 0);
-        expect(numberFormasted).toEqual("4.419");
+        expect(numberFormasted).toEqual("4.4");
     })
 
 });

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

package/test/general/object/isObject.test.js

@@ -0,0 +1,58 @@
+const { isObject } = require("../../../dist/cjs");
+
+describe("Undefined/empty arguments", function () {
+    test("Undefined argument", function () {
+        let result = isObject();
+        expect(result).toBe(false);
+    });
+
+    test("Undefined argument", function () {
+        let result = isObject(undefined);
+        expect(result).toBe(false);
+    });
+
+    test("Null argument", function () {
+        let result = isObject(null);
+        expect(result).toBe(false);
+    });
+
+    test("Empty array argument", function () {
+        let result = isObject([]);
+        expect(result).toBe(false);
+    });
+});
+
+describe("Different argument type", function () {
+    test("Boolean argument", function () {
+        let result = isObject(false);
+        expect(result).toBe(false);
+    });
+
+    test("Numeric argument", function () {
+        let result = isObject(0);
+        expect(result).toBe(false);
+    });
+
+    test("String argument", function () {
+        let result = isObject("Sales");
+        expect(result).toBe(false);
+    });
+});
+
+describe("Object type", function () {
+    test("Date Object", function () {
+        let param1 = new Date();
+        let result = isObject(param1);
+        expect(result).toBe(true);
+    });
+    
+    test("Empty but valid object", function () {
+        let result = isObject({});
+        expect(result).toBe(true);
+    });
+
+    test("Non-empty but valid object", function () {
+        let result = isObject({ Hello: "world" });
+        expect(result).toBe(true);
+    });
+});

package/test/general/object/omit.test.js

@@ -0,0 +1,92 @@
+const { omit } = require('../../../dist/cjs');
+
+const object1 = { tag1: 'Hello', tag2: 'World' };
+const object2 = { 0: 'Hello', 1: 'World' };
+
+describe('Testing with empty arguments', function () {
+    const empty1 = undefined;
+    const empty2 = [];
+    const empty3 = {};
+    const empty4 = null;
+
+    test('No arguments', function () {
+        const empty = omit();
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined variable', function () {
+        const empty = omit(empty1);
+        expect(empty).toStrictEqual(empty1);
+    });
+
+    test('Empty Array variable', function () {
+        const empty = omit(empty2);
+        expect(empty).toStrictEqual(empty2);
+    });
+
+    test('Empty Object variable', function () {
+        const empty = omit(empty3);
+        expect(empty).toStrictEqual(empty3);
+    });
+
+    test('Null variable', function () {
+        const empty = omit(empty3);
+        expect(empty).toStrictEqual(empty3);
+    });
+
+    test('Empty array second argument', function () {
+        const empty = omit(object1, empty2);
+        expect(empty).toStrictEqual(object1);
+    });
+
+    test('Null second argument', function () {
+        const empty = omit(object1 , empty4);
+        expect(empty).toStrictEqual(object1);
+    });
+});
+
+describe('Testing with different argument type', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+    const variable4 = ['Hello', 'World'];
+    const variable5 = [false, true]; 
+
+    test('String variable', function () {
+        const cDVariable1 = omit(variable1);
+        expect(cDVariable1).toStrictEqual(variable1);
+    });
+
+    test('Numeric variable', function () {
+        const cDVariable2 = omit(variable2);
+        expect(cDVariable2).toStrictEqual(variable2);
+    }); 
+
+    test('Boolean variable', function () {
+        const cDVariable3 = omit(variable3);
+        expect(cDVariable3).toStrictEqual(variable3);
+    });
+
+    test('Array variable', function () {
+        const cDVariable4 = omit(variable4);
+        expect(cDVariable4).toStrictEqual(variable4);
+    });
+
+    test('Array variable', function () {
+        const oObject1 = omit(object1, variable5);
+        expect(oObject1).toStrictEqual(object1);
+    });
+});
+
+
+describe('Creating an new reference by omiting some keys', function () {
+    test('Scenario with keys as string', function () {
+        const oObject1 = omit(object1, ['tag1']);
+        expect(oObject1).not.toBe(object1.tag1);
+    });
+
+    test('cenario with keys as number', function () {
+        const oObject1 = omit(object2, [1]);
+        expect(oObject1).not.toBe(object1[1]);
+    });
+});