@sankhyalabs/core 6.0.1 → 6.1.0-dev.2

package/test/util/StringUtils.spec.ts

@@ -1,63 +1,287 @@
 import { StringUtils } from '../../src/utils/StringUtils';
+import {
+  isEmptyCases,
+  replaceAccentuatedCharsCases,
+  replaceAccentuatedCharsKeepSymbolsCases,
+  replaceBlankCharactersCases,
+  replaceToSpaceCases,
+  replaceAllCases,
+  removeSpecialCharactersCases,
+  isStringCases,
+  decodeHtmlEntitiesCases,
+  hashCodeCases,
+  getBooleanValueCases,
+  padStartCases,
+  padEndCases,
+  compareCases,
+  toCamelCaseCases,
+  toPascalCaseCases,
+  toSnakeCaseCases,
+  toKebabCaseCases,
+  formatBytesCases,
+  prettyPrecisionCases,
+  isCaseableCases,
+  isLowerCaseCases,
+  getOppositeCaseCases,
+  getSpecialCharactersCases,
+  getArgumentNumberCases,
+  highlightValueCases
+} from '../testCases/StringUtilsTestCases';
 
-describe('StringUtils', function () {
+describe('StringUtils', function() {
 
-  it('valor vazio', function () {
-    let result = StringUtils.isEmpty('');
-    expect(result).toBe(true);
+  describe('isEmpty', () => {
+    isEmptyCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.isEmpty(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor em branco', function () {
-    let result = StringUtils.isEmpty(' ');
-    expect(result).toBe(true);
+
+  describe('replaceAccentuatedChars', () => {
+
+    it('should return the original value when called with an object without a toString method', () => {
+      const objWithoutToString = { value: 'someValue' };
+      jest.spyOn(StringUtils, 'replaceAccentuatedChars');
+
+      StringUtils.replaceAccentuatedChars(objWithoutToString as any);
+      expect(StringUtils.replaceAccentuatedChars).toHaveBeenCalledWith(objWithoutToString as any);
+    });
+
+
+    it('should return the original value when called with undefined', () => {
+      const undefinedArg: any = undefined;
+      jest.spyOn(StringUtils, 'replaceAccentuatedChars');
+
+      StringUtils.replaceAccentuatedChars(undefinedArg);
+      expect(StringUtils.replaceAccentuatedChars).toHaveBeenCalledWith(undefinedArg);
+    });
+
+    replaceAccentuatedCharsCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceAccentuatedChars(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+
+  });
+
+
+  describe('replaceAccentuatedCharsKeepSymbols', () => {
+    replaceAccentuatedCharsKeepSymbolsCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceAccentuatedCharsKeepSymbols(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('replaceBlankCharacters', () => {
+    replaceBlankCharactersCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${e.valueInput}`, () => {
+        expect(StringUtils.replaceBlankCharacters(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('replaceToSpace', () => {
+    replaceToSpaceCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}" and replaceList is ${JSON.stringify(e.replaceList)}`, () => {
+        expect(StringUtils.replaceToSpace(e.valueInput, e.replaceList)).toBe(e.valueOutput);
+      });
+    });
+
+  });
+
+
+  describe('replaceAll', () => {
+    replaceAllCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}", strFrom is "${e.strFrom}", and strTo is "${e.strTo}"`, () => {
+        expect(StringUtils.replaceAll(e.valueInput, e.strFrom, e.strTo)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('removeSpecialCharacters', () => {
+    removeSpecialCharactersCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.removeSpecialCharacters(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('isString', () => {
+    isStringCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is ${JSON.stringify(e.valueInput)}`, () => {
+        expect(StringUtils.isString(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('decodeHtmlEntities', () => {
+    decodeHtmlEntitiesCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.decodeHtmlEntities(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor null', function () {
-    let result = StringUtils.isEmpty(null);
-    expect(result).toBe(true);
+
+  describe('hashCode', () => {
+    hashCodeCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.hashCode(e.valueInput)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('getBooleanValue', () => {
+    getBooleanValueCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}" and defaultValue is ${e.defaultValue}`, () => {
+        expect(StringUtils.getBooleanValue(e.valueInput as any, e.defaultValue)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('padStart', () => {
+    padStartCases.forEach(e => {
+      const { str, len, pad } = e.valueInput;
+      it(`should return "${e.valueOutput}" when str="${str}", len=${len}, pad="${pad}"`, () => {
+        expect(StringUtils.padStart(str as any, len, pad)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('padEnd', () => {
+    padEndCases.forEach(e => {
+      const { str, len, pad } = e.valueInput;
+      it(`should return "${e.valueOutput}" when str="${str}", len=${len}, pad="${pad}"`, () => {
+        expect(StringUtils.padEnd(str as any, len, pad)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('compare', () => {
+    compareCases.forEach(e => {
+      const { a, b } = e.valueInput;
+      it(`should return ${e.valueOutput} when a="${a}" and b="${b}"`, () => {
+        expect(StringUtils.compare(a as any, b as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('toCamelCase', () => {
+    toCamelCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toCamelCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('toPascalCase', () => {
+    toPascalCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toPascalCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor undefined', function () {
-    let result = StringUtils.isEmpty(undefined);
-    expect(result).toBe(true);
+
+  describe('toSnakeCase', () => {
+    toSnakeCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toSnakeCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('valor 0', function () {
-    let result = StringUtils.isEmpty('0');
-    expect(result).toBe(false);
+
+  describe('toKebabCase', () => {
+    toKebabCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.toKebabCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('com valor', function () {
-    let result = StringUtils.isEmpty('ab');
-    expect(result).toBe(false);
+
+  describe('formatBytes', () => {
+    formatBytesCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is ${e.valueInput}`, () => {
+        expect(StringUtils.formatBytes(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('substitui vogais com acento por vogais sem acento', function () {
 
-    let resultadoInputMaiusculo = StringUtils.replaceAccentuatedChars('ÁÀÂÃÄ');
-    expect(resultadoInputMaiusculo).toBe('AAAAA');
+  describe('prettyPrecision', () => {
+    prettyPrecisionCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils['prettyPrecision'](e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+
+  describe('isCaseable', () => {
+    isCaseableCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.isCaseable(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+  describe('isLowerCase', () => {
+    isLowerCaseCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.isLowerCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
+
+  describe('getOppositeCase', () => {
+    getOppositeCaseCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getOppositeCase(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
+  });
 
-    let resultInputMinusculo = StringUtils.replaceAccentuatedChars('áàâãä');
-    expect(resultInputMinusculo).toBe('aaaaa');
 
-    let resultInputCedilhaMaiusculo = StringUtils.replaceAccentuatedChars('Ç');
-    expect(resultInputCedilhaMaiusculo).toBe('C');
+  describe('getSpecialCharacters', () => {
+    getSpecialCharactersCases.forEach(e => {
+      it(`should return ${JSON.stringify(e.valueOutput)} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getSpecialCharacters(e.valueInput as any)).toEqual(e.valueOutput);
+      });
+    });
   });
 
-  it('should return the original value when called with an object without a toString method', () => {
-    const objWithoutToString = { value: 'someValue' };
-    jest.spyOn(StringUtils, 'replaceAccentuatedCharsUpper');
 
-    StringUtils.replaceAccentuatedCharsUpper(objWithoutToString as any);
-    expect(StringUtils.replaceAccentuatedCharsUpper).toHaveBeenCalledWith(objWithoutToString as any);
+  describe('getArgumentNumber', () => {
+    getArgumentNumberCases.forEach(e => {
+      it(`should return ${e.valueOutput} when value is "${e.valueInput}"`, () => {
+        expect(StringUtils.getArgumentNumber(e.valueInput as any)).toBe(e.valueOutput);
+      });
+    });
   });
 
-  it('should return the original value when called with undefined', () => {
-    const undefinedArg: any = undefined;
-    jest.spyOn(StringUtils, 'replaceAccentuatedCharsUpper');
 
-    StringUtils.replaceAccentuatedCharsUpper(undefinedArg);
-    expect(StringUtils.replaceAccentuatedCharsUpper).toHaveBeenCalledWith(undefinedArg);
+  describe('highlightValue', () => {
+    highlightValueCases.forEach(e => {
+      it(`should return "${e.valueOutput}" when value is "${e.valueInput.value}" and argument is "${e.valueInput.argument}"`, () => {
+        expect(StringUtils.highlightValue(e.valueInput.argument as any, e.valueInput.matchFields, e.valueInput.value, e.valueInput.fieldMD, e.valueInput.forceMatch)).toBe(e.valueOutput);
+      });
+    });
   });
 
 });

package/test/util/TimeFormatter.spec.ts

@@ -1,26 +1,73 @@
 import { TimeFormatter } from '../../src/utils/TimeFormatter';
+import { validateTimeTestCases } from '../testCases/TimeFormatterTestUtils';
 
-describe('TimeFormatter', function () {
-    it("Case: input string unformated with showSeconds", function () {
-        let value = TimeFormatter.prepareValue("1110", false);
-        expect(value).toEqual("11:10");
+
+describe('TimeFormatter', () => {
+
+  describe('prepareValue', () => {
+
+    test('Case: input string unformated with showSeconds', () => {
+      let value = TimeFormatter.prepareValue('1110', false);
+      expect(value).toEqual('11:10');
+    });
+
+    test('Case: input string unformated without showSeconds', () => {
+      let value = TimeFormatter.prepareValue('1110', true);
+      expect(value).toEqual('00:11:10');
     });
 
-    it("Case: input string unformated without showSeconds", function () {
-        let value = TimeFormatter.prepareValue("1110", true);
-        expect(value).toEqual("00:11:10");
+    test('should format valid time without seconds', () => {
+      expect(TimeFormatter.prepareValue('1012', false)).toBe('10:12');
+      expect(TimeFormatter.prepareValue('12', false)).toBe('00:12');
+      expect(TimeFormatter.prepareValue('59', false)).toBe('00:59');
     });
 
-    
-    it("Case: validateTime", function () {
-        let isValid = TimeFormatter.validateTime("2525", false);
-        expect(isValid).toEqual(false);
-        isValid = TimeFormatter.validateTime("2525", true);
-        expect(isValid).toEqual(false);
-        isValid = TimeFormatter.validateTime("232920", true);
-        expect(isValid).toEqual(true);
-        isValid = TimeFormatter.validateTime("232920", false);
-        expect(isValid).toEqual(true);
+    test('should format valid time with seconds', () => {
+      expect(TimeFormatter.prepareValue('101200', true)).toBe('10:12:00');
+      expect(TimeFormatter.prepareValue('12', true)).toBe('00:00:12');
+      expect(TimeFormatter.prepareValue('1', true)).toBe('00:00:01');
     });
-    
+
+    test('should pad input with leading zeros for proper format', () => {
+      expect(TimeFormatter.prepareValue('1', false)).toBe('00:01');
+      expect(TimeFormatter.prepareValue('123', false)).toBe('01:23');
+      expect(TimeFormatter.prepareValue('12345', true)).toBe('01:23:45');
+    });
+
+    test('should return an empty string for invalid input', () => {
+      expect(TimeFormatter.prepareValue('', false)).toBe('');
+      expect(TimeFormatter.prepareValue(null as any, false)).toBe('');
+      expect(TimeFormatter.prepareValue(undefined as any, false)).toBe('');
+    });
+
+    test('should throw error when recieveng string', () => {
+      expect(() => {
+        TimeFormatter.prepareValue("abcd", false)
+      }).toThrow(Error);
+    })
+
+    test('should handle edge cases correctly', () => {
+      expect(TimeFormatter.prepareValue('0000', false)).toBe('00:00');
+      expect(TimeFormatter.prepareValue('2359', false)).toBe('23:59');
+      expect(TimeFormatter.prepareValue('000000', true)).toBe('00:00:00');
+      expect(TimeFormatter.prepareValue('235959', true)).toBe('23:59:59');
+    });
+
+    test('should format partially filled times correctly', () => {
+      expect(TimeFormatter.prepareValue('1', true)).toBe('00:00:01');
+      expect(TimeFormatter.prepareValue('123', true)).toBe('00:01:23');
+      expect(TimeFormatter.prepareValue('12', true)).toBe('00:00:12');
+    });
+
+  });
+
+
+  describe('validateTime', () => {
+    validateTimeTestCases.forEach(e => {
+      it(`should be ${e.expected} when [ value: ${e.value}, showSeconds: ${e.showSeconds}`, () => {
+        expect(TimeFormatter.validateTime(e.value, e.showSeconds)).toBe(e.expected);
+      });
+    });
+  });
+
 });

package/src/utils/test/objectUtils.spec.ts

@@ -1,109 +0,0 @@
-import ObjectUtils from '../ObjectUtils'
-
-describe("ObjectUtils", () => {
-    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);
-        });
-
-    });
-
-
-    it("should get an object value based on its path", async () => {
-        const obj = {
-            food: {
-                fruits: {
-                    apple: 1,
-                    banana: 2
-                }
-            }
-        };
-
-        const value = ObjectUtils.getProp(obj, "food.fruits.banana");
-        expect(value).toBe(2);
-    });
-
-    it("should get an object value based on its path", async () => {
-        const food = {
-            fruits: {
-                apple: 1,
-                banana: 2
-            }
-        }
-
-        const obj = { food };
-
-        const value = ObjectUtils.getProp(obj, "food");
-        expect(JSON.stringify(value)).toBe(JSON.stringify(food));
-    });
-
-    it("should return undefined if the path doesn't exist in the object", async () => {
-        const obj = {
-            food: {
-                fruits: {
-                    apple: 1,
-                    banana: 2
-                }
-            }
-        };
-
-        const value = ObjectUtils.getProp(obj, "vegetables");
-        expect(value).toBe(undefined);
-    });
-});