refactor testing

test/unit/sanitize.spec.js

@@ -1,95 +1,71 @@
 import { describe, it, expect } from 'vitest'
-import { sanitizeString, sanitizeIdentifier, sanitizeLabel } from '../../server/utils/sanitize.js'
+import { sanitizeString, sanitizeIdentifier, sanitizeLabel } from '../../server/utils/validation.js'
 
 describe('sanitize', () => {
   describe('sanitizeString', () => {
-    it('trims whitespace', () => {
-      expect(sanitizeString('  test  ')).toBe('test')
-      expect(sanitizeString('\n\ttest\n\t')).toBe('test')
+    it.each([
+      ['  test  ', 'test'],
+      ['\n\ttest\n\t', 'test'],
+      ['valid string', 'valid string'],
+      ['test123', 'test123'],
+    ])('trims whitespace and preserves valid: %s -> %s', (input, expected) => {
+      expect(sanitizeString(input)).toBe(expected)
     })
 
-    it('returns empty string for non-string input', () => {
-      expect(sanitizeString(null)).toBe('')
-      expect(sanitizeString(undefined)).toBe('')
-      expect(sanitizeString(123)).toBe('')
-      expect(sanitizeString({})).toBe('')
+    it.each([null, undefined, 123, {}])('returns empty for non-string: %s', (input) => {
+      expect(sanitizeString(input)).toBe('')
     })
 
     it('truncates strings exceeding max length', () => {
-      const longString = 'a'.repeat(2000)
-      expect(sanitizeString(longString, 1000).length).toBe(1000)
-    })
-
-    it('uses default max length', () => {
-      const longString = 'a'.repeat(2000)
-      expect(sanitizeString(longString).length).toBe(1000)
-    })
-
-    it('preserves valid strings', () => {
-      expect(sanitizeString('valid string')).toBe('valid string')
-      expect(sanitizeString('test123')).toBe('test123')
+      expect(sanitizeString('a'.repeat(2000), 1000).length).toBe(1000)
+      expect(sanitizeString('a'.repeat(2000)).length).toBe(1000)
     })
   })
 
   describe('sanitizeIdentifier', () => {
-    it('accepts valid identifiers', () => {
-      expect(sanitizeIdentifier('test123')).toBe('test123')
-      expect(sanitizeIdentifier('test_user')).toBe('test_user')
-      expect(sanitizeIdentifier('Test123')).toBe('Test123')
-      expect(sanitizeIdentifier('_test')).toBe('_test')
+    it.each([
+      ['test123', 'test123'],
+      ['test_user', 'test_user'],
+      ['Test123', 'Test123'],
+      ['_test', '_test'],
+      ['  test123  ', 'test123'],
+    ])('accepts valid identifier: %s -> %s', (input, expected) => {
+      expect(sanitizeIdentifier(input)).toBe(expected)
     })
 
-    it('rejects invalid characters', () => {
-      expect(sanitizeIdentifier('test-user')).toBe('')
-      expect(sanitizeIdentifier('test.user')).toBe('')
-      expect(sanitizeIdentifier('test user')).toBe('')
-      expect(sanitizeIdentifier('test@user')).toBe('')
+    it.each([
+      ['test-user'],
+      ['test.user'],
+      ['test user'],
+      ['test@user'],
+      [''],
+      ['   '],
+      ['a'.repeat(256)],
+    ])('rejects invalid identifier: %s', (input) => {
+      expect(sanitizeIdentifier(input)).toBe('')
     })
 
-    it('trims whitespace', () => {
-      expect(sanitizeIdentifier('  test123  ')).toBe('test123')
-    })
-
-    it('returns empty string for non-string input', () => {
-      expect(sanitizeIdentifier(null)).toBe('')
-      expect(sanitizeIdentifier(undefined)).toBe('')
-      expect(sanitizeIdentifier(123)).toBe('')
-    })
-
-    it('rejects empty strings', () => {
-      expect(sanitizeIdentifier('')).toBe('')
-      expect(sanitizeIdentifier('   ')).toBe('')
-    })
-
-    it('rejects strings exceeding max length', () => {
-      const longId = 'a'.repeat(256)
-      expect(sanitizeIdentifier(longId)).toBe('')
+    it.each([null, undefined, 123])('returns empty for non-string: %s', (input) => {
+      expect(sanitizeIdentifier(input)).toBe('')
     })
   })
 
   describe('sanitizeLabel', () => {
-    it('trims whitespace', () => {
-      expect(sanitizeLabel('  test label  ')).toBe('test label')
+    it.each([
+      ['  test label  ', 'test label'],
+      ['Valid Label', 'Valid Label'],
+      ['Test 123', 'Test 123'],
+    ])('trims whitespace and preserves valid: %s -> %s', (input, expected) => {
+      expect(sanitizeLabel(input)).toBe(expected)
+    })
+
+    it.each([null, undefined])('returns empty for non-string: %s', (input) => {
+      expect(sanitizeLabel(input)).toBe('')
     })
 
     it('truncates long labels', () => {
-      const longLabel = 'a'.repeat(2000)
-      expect(sanitizeLabel(longLabel, 500).length).toBe(500)
-    })
-
-    it('uses default max length', () => {
-      const longLabel = 'a'.repeat(2000)
-      expect(sanitizeLabel(longLabel).length).toBe(1000)
-    })
-
-    it('returns empty string for non-string input', () => {
-      expect(sanitizeLabel(null)).toBe('')
-      expect(sanitizeLabel(undefined)).toBe('')
-    })
-
-    it('preserves valid labels', () => {
-      expect(sanitizeLabel('Valid Label')).toBe('Valid Label')
-      expect(sanitizeLabel('Test 123')).toBe('Test 123')
+      expect(sanitizeLabel('a'.repeat(2000), 500).length).toBe(500)
+      expect(sanitizeLabel('a'.repeat(2000)).length).toBe(1000)
     })
   })
 })