chore: add tests for common-helpers package (#540)

Author: ymc9

packages/common-helpers/package.json

@@ -7,6 +7,7 @@
         "build": "tsc --noEmit && tsup-node",
         "watch": "tsup-node --watch",
         "lint": "eslint src --ext ts",
+        "test": "vitest run",
         "pack": "pnpm pack"
     },
     "keywords": [],
@@ -29,6 +30,7 @@
     },
     "devDependencies": {
         "@zenstackhq/typescript-config": "workspace:*",
-        "@zenstackhq/eslint-config": "workspace:*"
+        "@zenstackhq/eslint-config": "workspace:*",
+        "@zenstackhq/vitest-config": "workspace:*"
     }
 }

packages/common-helpers/test/case-conversion.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { lowerCaseFirst } from '../src/lower-case-first';
+import { upperCaseFirst } from '../src/upper-case-first';
+
+describe('lowerCaseFirst tests', () => {
+    it('should lowercase the first character', () => {
+        expect(lowerCaseFirst('Hello')).toBe('hello');
+        expect(lowerCaseFirst('WORLD')).toBe('wORLD');
+        expect(lowerCaseFirst('A')).toBe('a');
+    });
+
+    it('should handle already lowercase strings', () => {
+        expect(lowerCaseFirst('hello')).toBe('hello');
+        expect(lowerCaseFirst('world')).toBe('world');
+    });
+
+    it('should handle empty string', () => {
+        expect(lowerCaseFirst('')).toBe('');
+    });
+
+    it('should handle strings with numbers', () => {
+        expect(lowerCaseFirst('123abc')).toBe('123abc');
+    });
+
+    it('should handle strings with special characters', () => {
+        expect(lowerCaseFirst('!Hello')).toBe('!Hello');
+        expect(lowerCaseFirst('@World')).toBe('@World');
+    });
+});
+
+describe('upperCaseFirst tests', () => {
+    it('should uppercase the first character', () => {
+        expect(upperCaseFirst('hello')).toBe('Hello');
+        expect(upperCaseFirst('world')).toBe('World');
+        expect(upperCaseFirst('a')).toBe('A');
+    });
+
+    it('should handle already uppercase strings', () => {
+        expect(upperCaseFirst('Hello')).toBe('Hello');
+        expect(upperCaseFirst('WORLD')).toBe('WORLD');
+    });
+
+    it('should handle empty string', () => {
+        expect(upperCaseFirst('')).toBe('');
+    });
+
+    it('should handle strings with numbers', () => {
+        expect(upperCaseFirst('123abc')).toBe('123abc');
+    });
+
+    it('should handle strings with special characters', () => {
+        expect(upperCaseFirst('!hello')).toBe('!hello');
+        expect(upperCaseFirst('@world')).toBe('@world');
+    });
+});

packages/common-helpers/test/clone.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest';
+import { clone } from '../src/clone';
+
+describe('clone tests', () => {
+    describe('primitives', () => {
+        it('should return primitives as-is', () => {
+            expect(clone(42)).toBe(42);
+            expect(clone('hello')).toBe('hello');
+            expect(clone(true)).toBe(true);
+            expect(clone(false)).toBe(false);
+            expect(clone(null)).toBe(null);
+            expect(clone(undefined)).toBe(undefined);
+        });
+    });
+
+    describe('arrays', () => {
+        it('should clone simple arrays', () => {
+            const arr = [1, 2, 3];
+            const cloned = clone(arr);
+            expect(cloned).toEqual(arr);
+            expect(cloned).not.toBe(arr);
+        });
+
+        it('should deep clone nested arrays', () => {
+            const arr = [1, [2, 3], [4, [5, 6]]];
+            const cloned = clone(arr);
+            expect(cloned).toEqual(arr);
+            expect(cloned).not.toBe(arr);
+            expect(cloned[1]).not.toBe(arr[1]);
+            expect(cloned[2]).not.toBe(arr[2]);
+        });
+
+        it('should clone arrays with objects', () => {
+            const arr = [{ a: 1 }, { b: 2 }];
+            const cloned = clone(arr);
+            expect(cloned).toEqual(arr);
+            expect(cloned).not.toBe(arr);
+            expect(cloned[0]).not.toBe(arr[0]);
+            expect(cloned[1]).not.toBe(arr[1]);
+        });
+
+        it('should handle empty arrays', () => {
+            const arr: number[] = [];
+            const cloned = clone(arr);
+            expect(cloned).toEqual([]);
+            expect(cloned).not.toBe(arr);
+        });
+    });
+
+    describe('plain objects', () => {
+        it('should clone simple objects', () => {
+            const obj = { a: 1, b: 2 };
+            const cloned = clone(obj);
+            expect(cloned).toEqual(obj);
+            expect(cloned).not.toBe(obj);
+        });
+
+        it('should deep clone nested objects', () => {
+            const obj = { a: 1, b: { c: 2, d: { e: 3 } } };
+            const cloned = clone(obj);
+            expect(cloned).toEqual(obj);
+            expect(cloned).not.toBe(obj);
+            expect(cloned.b).not.toBe(obj.b);
+            expect(cloned.b.d).not.toBe(obj.b.d);
+        });
+
+        it('should clone objects with arrays', () => {
+            const obj = { a: [1, 2], b: { c: [3, 4] } };
+            const cloned = clone(obj);
+            expect(cloned).toEqual(obj);
+            expect(cloned).not.toBe(obj);
+            expect(cloned.a).not.toBe(obj.a);
+            expect(cloned.b.c).not.toBe(obj.b.c);
+        });
+
+        it('should handle empty objects', () => {
+            const obj = {};
+            const cloned = clone(obj);
+            expect(cloned).toEqual({});
+            expect(cloned).not.toBe(obj);
+        });
+
+        it('should handle objects with null prototype', () => {
+            const obj = Object.create(null);
+            obj.foo = 'bar';
+            const cloned = clone(obj);
+            expect(cloned).toEqual(obj);
+            expect(cloned).not.toBe(obj);
+        });
+    });
+
+    describe('non-plain objects', () => {
+        it('should return Date objects as-is', () => {
+            const date = new Date();
+            const cloned = clone(date);
+            expect(cloned).toBe(date);
+        });
+
+        it('should return RegExp objects as-is', () => {
+            const regex = /test/gi;
+            const cloned = clone(regex);
+            expect(cloned).toBe(regex);
+        });
+
+        it('should return class instances as-is', () => {
+            class MyClass {
+                value = 42;
+            }
+            const instance = new MyClass();
+            const cloned = clone(instance);
+            expect(cloned).toBe(instance);
+        });
+
+        it('should return functions as-is', () => {
+            const fn = () => 42;
+            const cloned = clone(fn);
+            expect(cloned).toBe(fn);
+        });
+    });
+
+    describe('mixed structures', () => {
+        it('should handle complex mixed structures', () => {
+            const complex = {
+                number: 42,
+                string: 'hello',
+                bool: true,
+                null: null,
+                array: [1, 2, { nested: 'value' }],
+                object: {
+                    a: [1, 2, 3],
+                    b: { c: 4 },
+                },
+            };
+            const cloned = clone(complex);
+            expect(cloned).toEqual(complex);
+            expect(cloned).not.toBe(complex);
+            expect(cloned.array).not.toBe(complex.array);
+            expect(cloned.array[2]).not.toBe(complex.array[2]);
+            expect(cloned.object).not.toBe(complex.object);
+            expect(cloned.object.a).not.toBe(complex.object.a);
+        });
+
+        it('should preserve primitive values in nested structures', () => {
+            const obj = { a: { b: { c: 42 } } };
+            const cloned = clone(obj);
+            expect(cloned.a.b.c).toBe(42);
+        });
+    });
+});

packages/common-helpers/test/enumerable.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { enumerate } from '../src/enumerable';
+
+describe('enumerate tests', () => {
+    it('should return empty array for null', () => {
+        expect(enumerate(null)).toEqual([]);
+    });
+
+    it('should return empty array for undefined', () => {
+        expect(enumerate(undefined)).toEqual([]);
+    });
+
+    it('should return array as-is', () => {
+        const arr = [1, 2, 3];
+        expect(enumerate(arr)).toBe(arr);
+        expect(enumerate(arr)).toEqual([1, 2, 3]);
+    });
+
+    it('should wrap scalar values in an array', () => {
+        expect(enumerate(42)).toEqual([42]);
+        expect(enumerate('hello')).toEqual(['hello']);
+        expect(enumerate(true)).toEqual([true]);
+        expect(enumerate(false)).toEqual([false]);
+    });
+
+    it('should handle empty arrays', () => {
+        const arr: number[] = [];
+        expect(enumerate(arr)).toBe(arr);
+        expect(enumerate(arr)).toEqual([]);
+    });
+
+    it('should handle objects', () => {
+        const obj = { a: 1 };
+        expect(enumerate(obj)).toEqual([obj]);
+    });
+
+    it('should handle nested arrays', () => {
+        const arr = [[1, 2], [3, 4]];
+        expect(enumerate(arr)).toBe(arr);
+        expect(enumerate(arr)).toEqual([[1, 2], [3, 4]]);
+    });
+
+    it('should handle functions', () => {
+        const fn = () => 42;
+        expect(enumerate(fn)).toEqual([fn]);
+    });
+
+    it('should handle zero', () => {
+        expect(enumerate(0)).toEqual([0]);
+    });
+
+    it('should handle empty string', () => {
+        expect(enumerate('')).toEqual(['']);
+    });
+});

packages/common-helpers/test/is-plain-object.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { isPlainObject } from '../src/is-plain-object';
+
+describe('isPlainObject tests', () => {
+    it('should return true for plain objects', () => {
+        expect(isPlainObject({})).toBe(true);
+        expect(isPlainObject({ a: 1 })).toBe(true);
+        expect(isPlainObject({ a: 1, b: { c: 2 } })).toBe(true);
+        expect(isPlainObject(Object.create(null))).toBe(true);
+    });
+
+    it('should return false for non-plain objects', () => {
+        expect(isPlainObject(null)).toBe(false);
+        expect(isPlainObject(undefined)).toBe(false);
+        expect(isPlainObject(42)).toBe(false);
+        expect(isPlainObject('string')).toBe(false);
+        expect(isPlainObject(true)).toBe(false);
+        expect(isPlainObject(false)).toBe(false);
+    });
+
+    it('should return false for arrays', () => {
+        expect(isPlainObject([])).toBe(false);
+        expect(isPlainObject([1, 2, 3])).toBe(false);
+    });
+
+    it('should return false for class instances', () => {
+        class MyClass {}
+        expect(isPlainObject(new MyClass())).toBe(false);
+        expect(isPlainObject(new Date())).toBe(false);
+        expect(isPlainObject(new Error())).toBe(false);
+        expect(isPlainObject(new RegExp(''))).toBe(false);
+    });
+
+    it('should return false for functions', () => {
+        expect(isPlainObject(() => {})).toBe(false);
+        expect(isPlainObject(function () {})).toBe(false);
+    });
+
+    it('should return true for objects with custom prototype', () => {
+        // Objects created with Object.create still have isPrototypeOf on their prototype chain
+        const obj = Object.create({ custom: 'prototype' });
+        expect(isPlainObject(obj)).toBe(true);
+    });
+
+    it('should handle objects without hasOwnProperty', () => {
+        const obj = Object.create(null);
+        obj.foo = 'bar';
+        expect(isPlainObject(obj)).toBe(true);
+    });
+});