test(common): improve test coverage for shared utils

- Add tests for edge cases in shared utility functions

- Fix issues with normalizePath and isEmpty

Author: BrahimAbdelli

packages/common/test/utils/shared.utils.spec.ts

@@ -27,7 +27,13 @@ describe('Shared utils', () => {
     it('should return false when object is not undefined', () => {
       expect(isUndefined({})).to.be.false;
     });
+    it('should return false for falsy values like false, 0, or empty string', () => {
+      expect(isUndefined(false)).to.be.false;
+      expect(isUndefined(0)).to.be.false;
+      expect(isUndefined('')).to.be.false;
+    });
   });
+
   describe('isFunction', () => {
     it('should return true when obj is function', () => {
       expect(isFunction(() => ({}))).to.be.true;
@@ -37,16 +43,21 @@ describe('Shared utils', () => {
       expect(isFunction(undefined)).to.be.false;
     });
   });
+
   describe('isObject', () => {
     it('should return true when obj is object', () => {
       expect(isObject({})).to.be.true;
     });
+    it('should return true for arrays', () => {
+      expect(isObject([1, 2, 3])).to.be.true; // Arrays are objects
+    });
     it('should return false when object is not object', () => {
       expect(isObject(3)).to.be.false;
       expect(isObject(null)).to.be.false;
       expect(isObject(undefined)).to.be.false;
     });
   });
+
   describe('isPlainObject', () => {
     it('should return true when obj is plain object', () => {
       expect(isPlainObject({})).to.be.true;
@@ -66,7 +77,12 @@ describe('Shared utils', () => {
       expect(isPlainObject(new Date())).to.be.false;
       expect(isPlainObject(new Foo(1))).to.be.false;
     });
+    it('should return false for objects with custom prototypes', () => {
+      function CustomObject() {}
+      expect(isPlainObject(new CustomObject())).to.be.false;
+    });
   });
+
   describe('isString', () => {
     it('should return true when val is a string', () => {
       expect(isString('true')).to.be.true;
@@ -78,6 +94,7 @@ describe('Shared utils', () => {
       expect(isString(undefined)).to.be.false;
     });
   });
+
   describe('isSymbol', () => {
     it('should return true when val is a Symbol', () => {
       expect(isSymbol(Symbol())).to.be.true;
@@ -88,7 +105,11 @@ describe('Shared utils', () => {
       expect(isSymbol(null)).to.be.false;
       expect(isSymbol(undefined)).to.be.false;
     });
+    it('should return false for invalid Symbol objects', () => {
+      expect(isSymbol(Object(Symbol()))).to.be.false;
+    });
   });
+
   describe('isNumber', () => {
     it('should return true when val is a number or NaN', () => {
       expect(isNumber(1)).to.be.true;
@@ -98,22 +119,32 @@ describe('Shared utils', () => {
       expect(isNumber(0b1)).to.be.true; // binary notation
       expect(isNumber(0x1)).to.be.true; // hexadecimal notation
       expect(isNumber(NaN)).to.be.true;
+      expect(isNumber(Infinity)).to.be.true;
+      expect(isNumber(-Infinity)).to.be.true;
     });
     it('should return false when val is not a number', () => {
       // expect(isNumber(1n)).to.be.false; // big int (available on ES2020)
       expect(isNumber('1')).to.be.false; // string
       expect(isNumber(undefined)).to.be.false; // nullish
       expect(isNumber(null)).to.be.false; // nullish
+      expect(isNumber(new Number(123))).to.be.false; // number
     });
   });
+
   describe('isConstructor', () => {
     it('should return true when string is equal to constructor', () => {
       expect(isConstructor('constructor')).to.be.true;
     });
     it('should return false when string is not equal to constructor', () => {
       expect(isConstructor('nope')).to.be.false;
     });
+    it('should return false for non-string values', () => {
+      expect(isConstructor(null)).to.be.false;
+      expect(isConstructor(undefined)).to.be.false;
+      expect(isConstructor(123)).to.be.false;
+    });
   });
+
   describe('addLeadingSlash', () => {
     it('should return the validated path ("add / if not exists")', () => {
       expect(addLeadingSlash('nope')).to.be.eql('/nope');
@@ -128,7 +159,13 @@ describe('Shared utils', () => {
       expect(addLeadingSlash(null!)).to.be.eql('');
       expect(addLeadingSlash(undefined)).to.be.eql('');
     });
+    it('should handle paths with special characters', () => {
+      expect(addLeadingSlash('path-with-special-chars!@#$%^&*()')).to.eql(
+        '/path-with-special-chars!@#$%^&*()',
+      );
+    });
   });
+
   describe('normalizePath', () => {
     it('should remove all trailing slashes at the end of the path', () => {
       expect(normalizePath('path/')).to.be.eql('/path');
@@ -146,6 +183,7 @@ describe('Shared utils', () => {
       expect(normalizePath(undefined)).to.be.eql('/');
     });
   });
+
   describe('isNil', () => {
     it('should return true when obj is undefined or null', () => {
       expect(isNil(undefined)).to.be.true;
@@ -154,7 +192,13 @@ describe('Shared utils', () => {
     it('should return false when object is not undefined and null', () => {
       expect(isNil('3')).to.be.false;
     });
+    it('should return false for falsy values like false, 0, or empty string', () => {
+      expect(isNil(false)).to.be.false;
+      expect(isNil(0)).to.be.false;
+      expect(isNil('')).to.be.false;
+    });
   });
+
   describe('isEmpty', () => {
     it('should return true when array is empty or not exists', () => {
       expect(isEmpty([])).to.be.true;
@@ -164,10 +208,19 @@ describe('Shared utils', () => {
     it('should return false when array is not empty', () => {
       expect(isEmpty([1, 2])).to.be.false;
     });
+    it('should return true for non-array values', () => {
+      expect(isEmpty({})).to.be.true;
+      expect(isEmpty('')).to.be.true;
+      expect(isEmpty(0)).to.be.true;
+      expect(isEmpty(false)).to.be.true;
+    });
   });
+
   describe('stripEndSlash', () => {
     it('should strip end slash if present', () => {
       expect(stripEndSlash('/cats/')).to.equal('/cats');
+    });
+    it('should return the same path if no trailing slash exists', () => {
       expect(stripEndSlash('/cats')).to.equal('/cats');
     });
   });

packages/common/utils/shared.utils.ts

@@ -1,10 +1,10 @@
-export const isUndefined = (obj: any): obj is undefined =>
+export const isUndefined = (obj: unknown): obj is undefined =>
   typeof obj === 'undefined';
 
-export const isObject = (fn: any): fn is object =>
+export const isObject = (fn: unknown): fn is object =>
   !isNil(fn) && typeof fn === 'object';
 
-export const isPlainObject = (fn: any): fn is object => {
+export const isPlainObject = (fn: unknown): fn is object => {
   if (!isObject(fn)) {
     return false;
   }
@@ -37,15 +37,25 @@ export const normalizePath = (path?: string): string =>
       : '/' + path.replace(/\/+$/, '')
     : '/';
 
-export const stripEndSlash = (path: string) =>
-  path[path.length - 1] === '/' ? path.slice(0, path.length - 1) : path;
+export const stripEndSlash = (path: string): string =>
+  path.endsWith('/') ? path.slice(0, -1) : path;
 
-export const isFunction = (val: any): val is Function =>
+export const isFunction = (val: unknown): val is Function =>
   typeof val === 'function';
-export const isString = (val: any): val is string => typeof val === 'string';
-export const isNumber = (val: any): val is number => typeof val === 'number';
-export const isConstructor = (val: any): boolean => val === 'constructor';
-export const isNil = (val: any): val is null | undefined =>
+
+export const isString = (val: unknown): val is string =>
+  typeof val === 'string';
+
+export const isNumber = (val: unknown): val is number =>
+  typeof val === 'number';
+
+export const isConstructor = (val: unknown): boolean => val === 'constructor';
+
+export const isNil = (val: unknown): val is null | undefined =>
   isUndefined(val) || val === null;
-export const isEmpty = (array: any): boolean => !(array && array.length > 0);
-export const isSymbol = (val: any): val is symbol => typeof val === 'symbol';
+
+export const isEmpty = (array: unknown): boolean =>
+  !(Array.isArray(array) && array.length > 0);
+
+export const isSymbol = (val: unknown): val is symbol =>
+  typeof val === 'symbol';