@qrvey/utils 1.1.0-9 → 1.1.2-1

package/test/general/object/get.test.js

@@ -0,0 +1,247 @@
+const { _get } = require('../../../dist/cjs');
+
+const base1 = {
+    tier1: {
+        tier2: {
+            destiny: 'Destiny Value'
+        }
+    }
+};
+
+const base2 = {
+    enabled: true,
+    displayed: false,
+    property: 'DAY',
+    value: ['0', '1'],
+    uiValue: [
+        { enabled: true, value: 'This is a Zero number' },
+        { enabled: false, value: 'This is a One number' },
+    ],
+    column: {
+        id: '123',
+        label: 'Hello World',
+        type: 'string',
+    },
+    dateGroup: null,
+    emptyValue: [],
+    extras: {},
+};
+
+const base3 = [
+    { name: 'Jose', lastName: 'Gonzalez' },
+    { name: 'Alex', lastName: 'Gonzalez' },
+];
+
+const base4 = [
+    { name: 'Jose', lastName: 'Gonzalez' },
+    'hello',
+    'world',
+    [
+        {
+            id: '1'
+        },
+        {
+            id: 2
+        },
+        [
+            1,
+            2,
+            [
+                3,
+                4
+            ]
+        ]
+    ]
+];
+
+describe('Testing a undefined arguments', function () {
+    const path1 = 'tier2';
+
+    test('Undefined Base', function () {
+        const empty = _get();
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined path', function () {
+        const empty = _get(base1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Undefined default value and no resolving a value from the object', function () {
+        const empty = _get(base1, path1);
+        expect(empty).toBeUndefined();
+    });
+});
+
+describe('Using different variable types on the base argument', function () {
+    const variable1 = 'Hello World';
+    const variable2 = 1;
+    const variable3 = true;
+    const variable4 = new Date();
+    const variable5 = null;
+
+    const path1 = 'testkey';
+
+    const defaultValue1 = 'Default Value';
+
+    test('String-Base type', function () {
+        const empty = _get(variable1, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Numeric-Base type', function () {
+        const empty = _get(variable2, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Boolean-Base type', function () {
+        const empty = _get(variable3, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Date-object type', function () {
+        const empty = _get(variable4, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Null type', function () {
+        const empty = _get(variable5, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Different base variable type and returning a default value', function () {
+        const value = _get(variable3, path1, defaultValue1);
+        expect(value).toBe(defaultValue1);
+    });
+});
+
+describe('Using different variable types on the path argument', function () {
+    const path1 = 1;
+    const path2 = true;
+    const path3 = ['uiValue', '[0]', 'value'];
+    const path4 = null;
+
+    const defaultValue1 = 'Default Value';
+
+    test('Numeric-type path', function () {
+        const empty = _get(base1, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Boolean-type path', function () {
+        const empty = _get(base1, path2);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Array-type path with an string as array-type item', function () {
+        const empty = _get(base2, path3);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Null type path', function () {
+        const empty = _get(base2, path4);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Different path variable type and returning a default value', function () {
+        const value = _get(base2, path3, defaultValue1);
+        expect(value).toBe(defaultValue1);
+    });
+});
+
+describe('Using string-type path but the evaluation does not match', function () {
+    const path1 = 'tier1,tier2';
+    const path2 = 'uiValue[].value';
+    const path3 = 'tier1..destiny';
+
+    test('Path separated by "commas"', function () {
+        const empty = _get(base1, path1);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Path with no index number', function () {
+        const empty = _get(base2, path2);
+        expect(empty).toBeUndefined();
+    });
+
+    test('Path with doble dot due to missing property', function () {
+        const empty = _get(base2, path3);
+        expect(empty).toBeUndefined();
+    });
+});
+
+describe('Returning values from the base object', function () {
+    const path1 = 'property';
+    const path2 = 'tier1.tier2';
+    const path3 = '[0]';
+    const path4 = 'uiValue[0].value';
+    const path5 = '[5]';
+    const path6 = ['uiValue', '0', 'value'];
+    const path7 = ['uiValue', [0], 'value'];
+    const path8 = 'dateGroup';
+    const path9 = 'emptyValue';
+    const path10 = 'extras';
+    const path11 = 'enabled';
+    const path12 = 'displayed';
+    const defaultValue1 = 'Default Value example';
+
+    test('Returning a value in the first tier', function () {
+        const returnedValue = _get(base2, path1);
+        expect(returnedValue).toBe(base2.property);
+    });
+
+    test('Returning a value in the second tier', function () {
+        const returnedValue = _get(base1, path2);
+        expect(returnedValue).toBe(base1.tier1.tier2);
+    });
+
+    test('Returning a value in array', function () {
+        const returnedValue = _get(base3, path3);
+        expect(returnedValue).toBe(base3[0]);
+    });
+
+    test('Returning a value in a combination of object/array items', function () {
+        const returnedValue = _get(base2, path4);
+        expect(returnedValue).toBe(base2.uiValue[0].value);
+    });
+
+    test('Returning a default value when a path is not matched', function () {
+        const returnedValue = _get(base4, path5, defaultValue1);
+        expect(returnedValue).toBe(defaultValue1);
+    });
+
+    test('Returning a value in with a array-type path', function () {
+        const returnedValue = _get(base2, path6);
+        expect(returnedValue).toBe(base2.uiValue[0].value);
+    });
+
+    test('Returning a value in with a array-type path 2', function () {
+        const returnedValue = _get(base2, path7);
+        expect(returnedValue).toBe(base2.uiValue[0].value);
+    });
+
+    test('Matching base and the path and returning a null value', function () {
+        const returnedValue = _get(base2, path8);
+        expect(returnedValue).toBeNull();
+    });
+
+    test('Matching base and the path and returning empty-array value', function () {
+        const returnedValue = _get(base2, path9);
+        expect(returnedValue).toBe(base2.emptyValue);
+    });
+
+    test('Matching base and the path and returning empty-object value', function () {
+        const returnedValue = _get(base2, path10);
+        expect(returnedValue).toBe(base2.extras);
+    });
+
+    test('Matching base and the path and returning a boolean value 1', function () {
+        const returnedValue = _get(base2, path11);
+        expect(returnedValue).toBe(base2.enabled);
+    });
+
+    test('Matching base and the path and returning a boolean value 2', function () {
+        const returnedValue = _get(base2, path12);
+        expect(returnedValue).toBe(base2.displayed);
+    });
+});

package/test/relative.test.js

@@ -11,8 +11,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-05-2021 00:00:00',
-            lte: '03-05-2021 23:59:59'
+            gte: '03/05/2021 00:00:00',
+            lte: '03/05/2021 23:59:59'
         });
     });
 
@@ -24,8 +24,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-01-2021 00:00:00',
-            lte: '03-31-2021 23:59:59'
+            gte: '03/01/2021 00:00:00',
+            lte: '03/31/2021 23:59:59'
         });
     });
 
@@ -38,8 +38,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '01-01-2020 00:00:00',
-            lte: '12-31-2021 23:59:59'
+            gte: '01/01/2020 00:00:00',
+            lte: '12/31/2021 23:59:59'
         });
     });
 
@@ -52,8 +52,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '02-28-2021 00:00:00',
-            lte: '03-06-2021 23:59:59'
+            gte: '02/28/2021 00:00:00',
+            lte: '03/06/2021 23:59:59'
         });
     });
 
@@ -67,8 +67,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '10-01-2020 00:00:00',
-            lte: '12-31-2020 23:59:59'
+            gte: '10/01/2020 00:00:00',
+            lte: '12/31/2020 23:59:59'
         });
     });
 
@@ -82,8 +82,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '04-01-2021 00:00:00',
-            lte: '05-31-2021 23:59:59'
+            gte: '04/01/2021 00:00:00',
+            lte: '05/31/2021 23:59:59'
         });
     });
 
@@ -98,8 +98,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '02-26-2021 00:00:00',
-            lte: '03-05-2021 23:59:59'
+            gte: '02/26/2021 00:00:00',
+            lte: '03/05/2021 23:59:59'
         });
     });
 
@@ -114,8 +114,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-06-2021 00:00:00',
-            lte: '06-05-2021 23:59:59'
+            gte: '03/06/2021 00:00:00',
+            lte: '06/05/2021 23:59:59'
         });
     });
 
@@ -130,8 +130,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-06-2021 00:00:00',
-            lte: '03-06-2021 23:59:59'
+            gte: '03/06/2021 00:00:00',
+            lte: '03/06/2021 23:59:59'
         }); 
     });
 
@@ -146,8 +146,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-05-2021 00:00:00',
-            lte: '03-05-2021 23:59:59'
+            gte: '03/05/2021 00:00:00',
+            lte: '03/05/2021 23:59:59'
         }); 
     });
 
@@ -162,8 +162,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-04-2021 00:00:00',
-            lte: '03-04-2021 23:59:59'
+            gte: '03/04/2021 00:00:00',
+            lte: '03/04/2021 23:59:59'
         }); 
     });
 
@@ -178,8 +178,8 @@ describe('Testing resolveRelative util', function () {
 
         const output = resolveRelative([statement], TODAY);
         expect(output[0]).toEqual({
-            gte: '03-05-2021 00:00:00',
-            lte: '03-05-2021 23:59:59'
+            gte: '03/05/2021 00:00:00',
+            lte: '03/05/2021 23:59:59'
         }); 
     });
 });