@sankhyalabs/core 6.0.1 → 6.1.0-dev.2

package/test/util/ObjectUtils.spec.ts

@@ -0,0 +1,572 @@
+import ObjectUtils from '../../src/utils/ObjectUtils';
+
+describe('ObjectUtils', () => {
+
+  describe('getProp', () => {
+    it('should get an object value based on its path', async () => {
+      const value = ObjectUtils.getProp(defaultObjectMock, 'food.fruits.banana');
+      expect(value).toBe(2);
+    });
+
+    it('should get an object value based on its path', async () => {
+      const value = ObjectUtils.getProp(defaultObjectMock, 'food');
+      expect(JSON.stringify(value)).toBe(JSON.stringify(defaultObjectMock.food));
+    });
+
+    it('should return undefined if the path doesn\'t exist in the object', async () => {
+      const value = ObjectUtils.getProp(defaultObjectMock, 'vegetables');
+      expect(value).toBe(undefined);
+    });
+  });
+
+
+  describe('hasEquivalentValues', () => {
+    it('should return true if both objects have the same property value', () => {
+      const obj1 = { value: 10 };
+      const obj2 = { value: 10 };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false if both objects have different property values', () => {
+      const obj1 = { value: 10 };
+      const obj2 = { value: 20 };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true if both objects are equivalent with custom property to compare', () => {
+      const obj1 = { customProp: 'hello' };
+      const obj2 = { customProp: 'hello' };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2, 'customProp')).toBe(true);
+    });
+
+    it('should return false if both objects are not equivalent with custom property to compare', () => {
+      const obj1 = { customProp: 'hello' };
+      const obj2 = { customProp: 'world' };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2, 'customProp')).toBe(false);
+    });
+
+    it('should return false if one object does not have the property', () => {
+      const obj1 = { value: 10 };
+      const obj2 = { anotherProp: 10 };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true if comparing primitive values directly', () => {
+      const obj1 = 5;
+      const obj2 = 5;
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false if comparing different primitive values', () => {
+      const obj1 = 5;
+      const obj2 = 10;
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true when comparing object with a null value', () => {
+      const obj1 = null;
+      const obj2 = null;
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false when comparing object with null and non-null value', () => {
+      const obj1 = null;
+      const obj2 = { value: 5 };
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true when comparing non-object values that are equal', () => {
+      const obj1 = 'same';
+      const obj2 = 'same';
+      expect(ObjectUtils.hasEquivalentProps(obj1, obj2)).toBe(true);
+    });
+
+  });
+
+
+  describe('copy', () => {
+    it('should copy a simple object', () => {
+      const original = { nome: 'Sankhya', cidade: 'Uberlandia' };
+      const copy = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+    });
+
+    it('should copy an array of objects', () => {
+      const original = [{ nome: 'Sankhya' }, { cidade: 'Uberlandia' }];
+      const copy: any = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+      expect(copy[0]).not.toBe(original[0]);
+    });
+
+    it('should copy an object with nested properties', () => {
+      const original = { pessoa: { nome: 'Sankhya', cidade: 'Uberlandia' } };
+      const copy: any = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+      expect(copy.pessoa).not.toBe(original.pessoa);
+    });
+
+    it('should copy an object with null or undefined values', () => {
+      const original = { nome: null, cidade: undefined, idade: 30 };
+      const copy = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+    });
+
+    it('should copy an empty object', () => {
+      const original = {};
+      const copy = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+    });
+
+    it('should copy an object with mixed types of values', () => {
+      const original = {
+        numero: 123,
+        texto: 'Test',
+        array: [1, 2, 3],
+        objeto: { chave: 'valor' },
+      };
+      const copy: any = ObjectUtils.copy(original);
+
+      expect(copy).toEqual(original);
+      expect(copy).not.toBe(original);
+      expect(copy.array).not.toBe(original.array);
+      expect(copy.objeto).not.toBe(original.objeto);
+    });
+  });
+
+
+  describe('objectToString', () => {
+    it('should convert a simple object to JSON string', () => {
+      const original = { nome: 'Sankhya', cidade: 'Uberlandia' };
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('{"nome":"Sankhya","cidade":"Uberlandia"}');
+    });
+
+    it('should convert an array of objects to JSON string', () => {
+      const original = [{ nome: 'Sankhya' }, { cidade: 'Uberlandia' }];
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('[{"nome":"Sankhya"},{"cidade":"Uberlandia"}]');
+    });
+
+    it('should convert a nested object to JSON string', () => {
+      const original = { pessoa: { nome: 'Sankhya', cidade: 'Uberlandia' } };
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('{"pessoa":{"nome":"Sankhya","cidade":"Uberlandia"}}');
+    });
+
+    it('should convert an object with null and undefined values to JSON string', () => {
+      const original = { nome: null, cidade: undefined, idade: 30 };
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('{"nome":null,"idade":30}');
+    });
+
+    it('should convert an empty object to JSON string', () => {
+      const original = {};
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('{}');
+    });
+
+    it('should convert an object with mixed types of values to JSON string', () => {
+      const original = {
+        numero: 123,
+        texto: 'Test',
+        array: [1, 2, 3],
+        objeto: { chave: 'valor' },
+      };
+      const jsonString = ObjectUtils.objectToString(original);
+
+      expect(jsonString).toBe('{"numero":123,"texto":"Test","array":[1,2,3],"objeto":{"chave":"valor"}}');
+    });
+  });
+
+
+  describe('stringToObject', () => {
+
+    it('should convert a simple JSON string to an object', () => {
+      const jsonString = '{"nome":"Sankhya","cidade":"Uberlandia"}';
+      const parsedObject = ObjectUtils.stringToObject(jsonString);
+
+      expect(parsedObject).toEqual({ nome: 'Sankhya', cidade: 'Uberlandia' });
+    });
+
+    it('should convert a JSON string representing an array of objects to an array of objects', () => {
+      const jsonString = '[{"nome":"Sankhya"},{"cidade":"Uberlandia"}]';
+      const parsedObject = ObjectUtils.stringToObject(jsonString);
+
+      expect(parsedObject).toEqual([{ nome: 'Sankhya' }, { cidade: 'Uberlandia' }]);
+    });
+
+    it('should convert a JSON string representing a nested object to an object', () => {
+      const jsonString = '{"pessoa":{"nome":"Sankhya","cidade":"Uberlandia"}}';
+      const parsedObject = ObjectUtils.stringToObject(jsonString);
+
+      expect(parsedObject).toEqual({ pessoa: { nome: 'Sankhya', cidade: 'Uberlandia' } });
+    });
+
+    it('should convert a JSON string with null and undefined values to an object', () => {
+      const jsonString = '{"nome":null,"cidade":null,"idade":30}';
+      const parsedObject = ObjectUtils.stringToObject(jsonString);
+
+      expect(parsedObject).toEqual({ nome: null, cidade: null, idade: 30 });
+    });
+
+    it('should convert an empty JSON string to an empty object', () => {
+      const jsonString = '{}';
+      const parsedObject = ObjectUtils.stringToObject(jsonString);
+
+      expect(parsedObject).toEqual({});
+    });
+
+    it('should throw an error for an invalid JSON string', () => {
+      const invalidJsonString = '{"nome": "Sankhya", "cidade": "Uberlandia"';
+
+      expect(() => {
+        ObjectUtils.stringToObject(invalidJsonString);
+      }).toThrow(SyntaxError);
+    });
+  });
+
+
+  describe('sortByProperty', () => {
+
+    it('should sort an object by a numerical property', () => {
+      const original = {
+        obj1: { id: 3, nome: 'Sankhya' },
+        obj2: { id: 1, nome: 'Uberlandia' },
+        obj3: { id: 2, nome: 'Tech' },
+      };
+      const sorted = ObjectUtils.sortByProperty(original, 'id');
+
+      const expected = {
+        obj2: { id: 1, nome: 'Uberlandia' },
+        obj3: { id: 2, nome: 'Tech' },
+        obj1: { id: 3, nome: 'Sankhya' },
+      };
+
+      expect(sorted).toEqual(expected);
+    });
+
+    it('should sort an object by a string property', () => {
+      const original = {
+        obj1: { nome: 'Sankhya' },
+        obj2: { nome: 'Uberlandia' },
+        obj3: { nome: 'Tech' },
+      };
+      const sorted = ObjectUtils.sortByProperty(original, 'nome');
+
+      const expected = {
+        obj3: { nome: 'Tech' },
+        obj2: { nome: 'Uberlandia' },
+        obj1: { nome: 'Sankhya' },
+      };
+
+      expect(sorted).toEqual(expected);
+    });
+
+    it('should handle null values correctly when sorting', () => {
+      const original = {
+        obj1: { id: 3, nome: 'Sankhya' },
+        obj2: { id: null, nome: 'Uberlandia' },
+        obj3: { id: 2, nome: 'Tech' },
+      };
+      const sorted = ObjectUtils.sortByProperty(original, 'id');
+
+      const expected = {
+        obj2: { id: null, nome: 'Uberlandia' },
+        obj3: { id: 2, nome: 'Tech' },
+        obj1: { id: 3, nome: 'Sankhya' },
+      };
+
+      expect(sorted).toEqual(expected);
+    });
+
+  });
+
+
+  describe('removeEmptyValues', () => {
+    it('should remove properties with null or undefined values in a simple object', () => {
+      const original = {
+        nome: 'Sankhya',
+        cidade: null,
+        idade: undefined,
+        pais: 'Brasil',
+      };
+      const result = ObjectUtils.removeEmptyValues(original);
+
+      const expected = { nome: 'Sankhya', pais: 'Brasil' };
+      expect(result).toEqual(expected);
+    });
+
+    it('should remove properties with null or undefined values in a nested object', () => {
+      const original = {
+        pessoa: {
+          nome: 'Sankhya',
+          idade: null,
+          endereco: {
+            rua: 'Av. Brasil',
+            cidade: undefined,
+          },
+        },
+        empresa: {
+          nome: 'Tech',
+          sede: null,
+        },
+      };
+      const result = ObjectUtils.removeEmptyValues(original);
+
+      const expected = {
+        pessoa: {
+          nome: 'Sankhya',
+          endereco: { rua: 'Av. Brasil' },
+        },
+        empresa: { nome: 'Tech' },
+      };
+
+      expect(result).toEqual(expected);
+    });
+
+    it('should remove empty values in an array inside an object', () => {
+      const original = {
+        pessoas: [
+          { nome: 'Sankhya', idade: null },
+          { nome: 'Uberlandia', idade: undefined },
+          { nome: 'Tech', idade: 30 },
+        ],
+      };
+      const result = ObjectUtils.removeEmptyValues(original);
+
+      const expected = {
+        pessoas: {
+          0: { nome: 'Sankhya' },
+          1: { nome: 'Uberlandia' },
+          2: { nome: 'Tech', idade: 30 },
+        },
+      };
+
+      expect(result).toEqual(expected);
+    });
+
+    it('should not modify an object with no null or undefined values', () => {
+      const original = {
+        nome: 'Sankhya',
+        cidade: 'Uberlandia',
+        idade: 30,
+      };
+      const result = ObjectUtils.removeEmptyValues(original);
+
+      expect(result).toEqual(original);
+    });
+
+    it('should return an empty object if all properties are removed', () => {
+      const original = {
+        nome: null,
+        cidade: undefined,
+      };
+      const result = ObjectUtils.removeEmptyValues(original);
+
+      const expected = {};
+      expect(result).toEqual(expected);
+    });
+  });
+
+
+  describe('equals', () => {
+
+    it('should return true for identical objects', () => {
+      const obj1 = { nome: 'Sankhya', idade: 30 };
+      const obj2 = { nome: 'Sankhya', idade: 30 };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false for different objects', () => {
+      const obj1 = { nome: 'Sankhya', idade: 30 };
+      const obj2 = { nome: 'Uberlandia', idade: 25 };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true for identical nested objects', () => {
+      const obj1 = { pessoa: { nome: 'Sankhya', idade: 30 }, cidade: 'Uberlandia' };
+      const obj2 = { pessoa: { nome: 'Sankhya', idade: 30 }, cidade: 'Uberlandia' };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false for different nested objects', () => {
+      const obj1 = { pessoa: { nome: 'Sankhya', idade: 30 }, cidade: 'Uberlandia' };
+      const obj2 = { pessoa: { nome: 'Tech', idade: 25 }, cidade: 'Uberlandia' };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(false);
+    });
+
+    it('should return false for objects with different types of properties', () => {
+      const obj1 = { nome: 'Sankhya', ativo: true, idade: 30 };
+      const obj2 = { nome: 'Sankhya', ativo: 'true', idade: 30 };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(false);
+    });
+
+    it('should return true for identical arrays', () => {
+      const arr1 = [1, 2, 3];
+      const arr2 = [1, 2, 3];
+
+      expect(ObjectUtils.equals(arr1, arr2)).toBe(true);
+    });
+
+    it('should return false for different arrays', () => {
+      const arr1 = [1, 2, 3];
+      const arr2 = [3, 2, 1];
+
+      expect(ObjectUtils.equals(arr1, arr2)).toBe(false);
+    });
+
+    it('should return true for empty objects', () => {
+      const obj1 = {};
+      const obj2 = {};
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(true);
+    });
+
+    it('should return false when comparing different types (object vs array)', () => {
+      const obj1 = { nome: 'Sankhya' };
+      const arr2 = ['Sankhya'];
+
+      expect(ObjectUtils.equals(obj1, arr2)).toBe(false);
+    });
+
+    it('should return true for objects with null and undefined treated as different', () => {
+      const obj1 = { nome: null };
+      const obj2 = { nome: undefined };
+
+      expect(ObjectUtils.equals(obj1, obj2)).toBe(false);
+    });
+  });
+
+
+  describe('isEmptySafetyCheck', () => {
+    it('should return true for an empty object', () => {
+      const obj = {};
+      expect(ObjectUtils.isEmptySafetyCheck(obj)).toBe(true);
+    });
+
+    it('should return false for an object with properties', () => {
+      const obj = { nome: 'Sankhya' };
+      expect(ObjectUtils.isEmptySafetyCheck(obj)).toBe(false);
+    });
+
+    it('should return false for an object with nested properties', () => {
+      const obj = { pessoa: { nome: 'Sankhya' } };
+      expect(ObjectUtils.isEmptySafetyCheck(obj)).toBe(false);
+    });
+
+    it('should return false for an empty array', () => {
+      const arr: any[] = [];
+      expect(ObjectUtils.isEmptySafetyCheck(arr)).toBe(false);
+    });
+
+    it('should return false for an object with null or undefined properties', () => {
+      const obj = { nome: null, idade: undefined };
+      expect(ObjectUtils.isEmptySafetyCheck(obj)).toBe(false);
+    });
+
+    it('should return false for a non-empty array object', () => {
+      const obj = [1, 2, 3];
+      expect(ObjectUtils.isEmptySafetyCheck(obj)).toBe(false);
+    });
+
+    it('should handle null gracefully and return true', () => {
+      const obj = null;
+      expect(ObjectUtils.isEmptySafetyCheck(obj as any)).toBe(true);
+    });
+
+    it('should handle undefined gracefully and return true', () => {
+      const obj = undefined;
+      expect(ObjectUtils.isEmptySafetyCheck(obj as any)).toBe(true);
+    });
+
+    it('should return false for primitive values (numbers, strings)', () => {
+      expect(ObjectUtils.isEmptySafetyCheck('' as any)).toBe(false);
+      expect(ObjectUtils.isEmptySafetyCheck(0 as any)).toBe(false);
+      expect(ObjectUtils.isEmptySafetyCheck(42 as any)).toBe(false);
+    });
+
+    it('should return false for functions', () => {
+      const func = () => {
+      };
+      expect(ObjectUtils.isEmptySafetyCheck(func as any)).toBe(false);
+    });
+  });
+
+
+  describe('isNotEmptySafetyCheck', () => {
+    it('should return false for an empty object', () => {
+      const obj = {};
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj)).toBe(false);
+    });
+
+    it('should return true for an object with properties', () => {
+      const obj = { nome: 'Sankhya' };
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj)).toBe(true);
+    });
+
+    it('should return true for an object with nested properties', () => {
+      const obj = { pessoa: { nome: 'Sankhya' } };
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj)).toBe(true);
+    });
+
+    it('should return true for an empty array', () => {
+      const arr: any[] = [];
+      expect(ObjectUtils.isNotEmptySafetyCheck(arr)).toBe(true);
+    });
+
+    it('should return true for an object with null or undefined properties', () => {
+      const obj = { nome: null, idade: undefined };
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj)).toBe(true);
+    });
+
+    it('should return true for a non-empty array object', () => {
+      const obj = [1, 2, 3];
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj)).toBe(true);
+    });
+
+    it('should handle null gracefully and return false', () => {
+      const obj = null;
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj as any)).toBe(false);
+    });
+
+    it('should handle undefined gracefully and return false', () => {
+      const obj = undefined;
+      expect(ObjectUtils.isNotEmptySafetyCheck(obj as any)).toBe(false);
+    });
+
+    it('should return false for primitive values (numbers, strings)', () => {
+      expect(ObjectUtils.isNotEmptySafetyCheck('' as any)).toBe(true);
+      expect(ObjectUtils.isNotEmptySafetyCheck(0 as any)).toBe(true);
+      expect(ObjectUtils.isNotEmptySafetyCheck(42 as any)).toBe(true);
+    });
+
+    it('should return true for functions', () => {
+      const func = () => {
+      };
+      expect(ObjectUtils.isNotEmptySafetyCheck(func as any)).toBe(true);
+    });
+  });
+
+});
+
+const defaultObjectMock = { food: { fruits: { apple: 1, banana: 2 } } };