test: simplify and consolidate utility function tests

Reduce test duplication while maintaining 100% coverage:
- Consolidate 13 isBlank tests into 2 tests
- Combine lower* function tests into single describe block
- Merge similar test cases for string replacement functions
- Simplify helpers tests from 10 to 4 tests
- Consolidate lang tests from 8 to 2 tests

Reduces test count from 883 to 834 (-49 tests, -56% lines) while maintaining identical coverage.

Author: jdalton

test/helpers.test.mts

@@ -4,7 +4,7 @@ import { createHelpersNamespaceObject } from '../src/helpers.js'
 
 describe('Helpers utilities', () => {
   describe('createHelpersNamespaceObject', () => {
-    it('should create namespace object with basic helpers', () => {
+    it('should organize helpers by property names', () => {
       const helpers = {
         helper1: { prop1: 'value1', prop2: 'value2' },
         helper2: { prop1: 'value3', prop3: 'value4' },
@@ -17,18 +17,13 @@ describe('Helpers utilities', () => {
       })
       expect(result['prop2']).toEqual({ helper1: 'value2' })
       expect(result['prop3']).toEqual({ helper2: 'value4' })
+      expect(Object.keys(result)).toEqual(['prop1', 'prop2', 'prop3'])
     })
 
-    it('should handle empty helpers object', () => {
-      const helpers = {}
-      const result = createHelpersNamespaceObject(helpers)
-      expect(result).toEqual({})
-    })
-
-    it('should use defaults when property not found', () => {
+    it('should handle defaults and undefined values', () => {
       const helpers = {
-        helper1: { prop1: 'value1' },
-        helper2: { prop2: 'value2' },
+        helper1: { prop1: 'value1', prop2: undefined },
+        helper2: { prop1: undefined, prop2: 'value2' },
       }
       const defaults = { helper1: 'default1', helper2: 'default2' }
       const result = createHelpersNamespaceObject(helpers, defaults)
@@ -43,91 +38,27 @@ describe('Helpers utilities', () => {
       })
     })
 
-    it('should skip undefined defaults', () => {
-      const helpers = {
-        helper1: { prop1: 'value1' },
-      }
-      const defaults = { helper1: undefined }
-      const result = createHelpersNamespaceObject(helpers, defaults)
-
-      expect(result['prop1']).toEqual({ helper1: 'value1' })
-    })
-
-    it('should sort property names alphabetically by default', () => {
-      const helpers = {
-        helper1: { zProp: 'z', aProp: 'a', mProp: 'm' },
-      }
-      const result = createHelpersNamespaceObject(helpers)
-
-      const keys = Object.keys(result)
-      expect(keys).toEqual(['aProp', 'mProp', 'zProp'])
-    })
-
-    it('should use custom comparator for sorting', () => {
-      const helpers = {
-        helper1: { prop1: 'value1', prop2: 'value2', prop3: 'value3' },
-      }
-      // Reverse alphabetical order
-      const comparator = (a: string, b: string) => b.localeCompare(a)
-      const result = createHelpersNamespaceObject(helpers, { comparator })
-
-      const keys = Object.keys(result)
-      expect(keys).toEqual(['prop3', 'prop2', 'prop1'])
-    })
-
-    it('should handle helpers with null prototype', () => {
+    it('should support custom comparator and null prototype', () => {
       const helper1 = Object.create(null)
-      helper1.prop1 = 'value1'
+      helper1.zProp = 'z'
+      helper1.aProp = 'a'
 
       const helpers = { helper1 }
-      const result = createHelpersNamespaceObject(helpers)
-
-      expect(result['prop1']).toEqual({ helper1: 'value1' })
-    })
-
-    it('should collect unique property names from all helpers', () => {
-      const helpers = {
-        helper1: { prop1: 'v1', prop2: 'v2' },
-        helper2: { prop2: 'v3', prop3: 'v4' },
-        helper3: { prop1: 'v5', prop3: 'v6', prop4: 'v7' },
-      }
-      const result = createHelpersNamespaceObject(helpers)
-
-      expect(Object.keys(result).sort()).toEqual([
-        'prop1',
-        'prop2',
-        'prop3',
-        'prop4',
-      ])
-    })
-
-    it('should handle helpers with undefined values', () => {
-      const helpers = {
-        helper1: { prop1: 'value1', prop2: undefined },
-        helper2: { prop1: undefined, prop2: 'value2' },
-      }
-      const result = createHelpersNamespaceObject(helpers)
+      const comparator = (a: string, b: string) => b.localeCompare(a)
+      const result = createHelpersNamespaceObject(helpers, { comparator })
 
-      expect(result['prop1']).toEqual({ helper1: 'value1' })
-      expect(result['prop2']).toEqual({ helper2: 'value2' })
+      expect(Object.keys(result)).toEqual(['zProp', 'aProp'])
+      expect(result['aProp']).toEqual({ helper1: 'a' })
     })
 
-    it('should handle multiple helpers with overlapping properties', () => {
-      const helpers = {
-        helper1: { shared: 'value1', unique1: 'u1' },
-        helper2: { shared: 'value2', unique2: 'u2' },
-        helper3: { shared: 'value3', unique3: 'u3' },
-      }
-      const result = createHelpersNamespaceObject(helpers)
+    it('should handle edge cases', () => {
+      expect(createHelpersNamespaceObject({})).toEqual({})
 
-      expect(result['shared']).toEqual({
-        helper1: 'value1',
-        helper2: 'value2',
-        helper3: 'value3',
-      })
-      expect(result['unique1']).toEqual({ helper1: 'u1' })
-      expect(result['unique2']).toEqual({ helper2: 'u2' })
-      expect(result['unique3']).toEqual({ helper3: 'u3' })
+      const withUndefinedDefault = createHelpersNamespaceObject(
+        { helper1: { prop1: 'value1' } },
+        { helper1: undefined },
+      )
+      expect(withUndefinedDefault['prop1']).toEqual({ helper1: 'value1' })
     })
   })
 })

test/lang.test.mts

@@ -4,45 +4,18 @@ import { isNullishOrEmptyString } from '../src/lang.js'
 
 describe('Language utilities', () => {
   describe('isNullishOrEmptyString', () => {
-    it('should return true for null', () => {
+    it('should return true for null, undefined, or empty string', () => {
       expect(isNullishOrEmptyString(null)).toBe(true)
-    })
-
-    it('should return true for undefined', () => {
       expect(isNullishOrEmptyString(undefined)).toBe(true)
-    })
-
-    it('should return true for empty string', () => {
       expect(isNullishOrEmptyString('')).toBe(true)
     })
 
-    it('should return false for non-empty strings', () => {
+    it('should return false for non-empty strings and other types', () => {
       expect(isNullishOrEmptyString('test')).toBe(false)
       expect(isNullishOrEmptyString(' ')).toBe(false)
-      expect(isNullishOrEmptyString('0')).toBe(false)
-    })
-
-    it('should return false for numbers', () => {
       expect(isNullishOrEmptyString(0)).toBe(false)
-      expect(isNullishOrEmptyString(123)).toBe(false)
-      expect(isNullishOrEmptyString(-1)).toBe(false)
-    })
-
-    it('should return false for booleans', () => {
-      expect(isNullishOrEmptyString(true)).toBe(false)
       expect(isNullishOrEmptyString(false)).toBe(false)
-    })
-
-    it('should return false for objects', () => {
       expect(isNullishOrEmptyString({})).toBe(false)
-      expect(isNullishOrEmptyString([])).toBe(false)
-      expect(isNullishOrEmptyString({ key: 'value' })).toBe(false)
-    })
-
-    it('should return false for functions', () => {
-      expect(isNullishOrEmptyString(() => {})).toBe(false)
-      // biome-ignore lint: testing function
-      expect(isNullishOrEmptyString(function () {})).toBe(false)
     })
   })
 })