refactor testing

test/unit/validation.spec.js

@@ -20,33 +20,56 @@ describe('validation', () => {
         source_type: 'mjpeg',
       })
       expect(result.valid).toBe(true)
-      expect(result.data).toBeDefined()
       expect(result.data.device_type).toBe('traffic')
     })
 
-    it('rejects invalid coordinates', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 'invalid',
-        lng: -74.0060,
-      })
+    it.each([
+      [{ name: 'Test', lat: 'invalid', lng: -74.0060 }, 'lat and lng required as finite numbers'],
+      [null, 'body required'],
+    ])('rejects invalid input: %j', (input, errorMsg) => {
+      const result = validateDevice(input)
       expect(result.valid).toBe(false)
-      expect(result.errors).toContain('lat and lng required as finite numbers')
-    })
-
-    it('rejects non-object input', () => {
-      const result = validateDevice(null)
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('body required')
+      expect(result.errors).toContain(errorMsg)
     })
 
     it('defaults device_type to feed', () => {
+      const result = validateDevice({ name: 'Test', lat: 40.7128, lng: -74.0060 })
+      expect(result.valid).toBe(true)
+      expect(result.data.device_type).toBe('feed')
+    })
+
+    it('defaults stream_url to empty string', () => {
+      const result = validateDevice({ name: 'Test', lat: 40.7128, lng: -74.0060 })
+      expect(result.valid).toBe(true)
+      expect(result.data.stream_url).toBe('')
+    })
+
+    it('defaults invalid source_type to mjpeg', () => {
       const result = validateDevice({
         name: 'Test',
         lat: 40.7128,
         lng: -74.0060,
+        source_type: 'invalid',
       })
-      expect(result.data.device_type).toBe('feed')
+      expect(result.valid).toBe(true)
+      expect(result.data.source_type).toBe('mjpeg')
+    })
+
+    it.each([
+      [{ name: 'Test', lat: 40.7128, lng: -74.0060 }, null],
+      [{ name: 'Test', lat: 40.7128, lng: -74.0060, config: { key: 'value' } }, '{"key":"value"}'],
+      [{ name: 'Test', lat: 40.7128, lng: -74.0060, config: '{"key":"value"}' }, '{"key":"value"}'],
+      [{ name: 'Test', lat: 40.7128, lng: -74.0060, config: null }, null],
+    ])('handles config: %j -> %s', (input, expected) => {
+      const result = validateDevice(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.config).toBe(expected)
+    })
+
+    it('defaults vendor to null', () => {
+      const result = validateDevice({ name: 'Test', lat: 40.7128, lng: -74.0060 })
+      expect(result.valid).toBe(true)
+      expect(result.data.vendor).toBeNull()
     })
   })
 
@@ -54,8 +77,7 @@ describe('validation', () => {
     it('validates partial updates', () => {
       const result = validateUpdateDevice({ name: 'Updated', lat: 40.7128 })
       expect(result.valid).toBe(true)
-      expect(result.data.name).toBe('Updated')
-      expect(result.data.lat).toBe(40.7128)
+      expect(result.data).toMatchObject({ name: 'Updated', lat: 40.7128 })
     })
 
     it('allows empty updates', () => {
@@ -64,34 +86,78 @@ describe('validation', () => {
       expect(Object.keys(result.data).length).toBe(0)
     })
 
-    it('rejects invalid device_type', () => {
-      const result = validateUpdateDevice({ device_type: 'invalid' })
+    it.each([
+      [{ device_type: 'invalid' }, 'Invalid device_type'],
+    ])('rejects invalid input: %j', (input, errorMsg) => {
+      const result = validateUpdateDevice(input)
       expect(result.valid).toBe(false)
-      expect(result.errors).toContain('Invalid device_type')
+      expect(result.errors).toContain(errorMsg)
     })
 
-    it('handles device_type undefined', () => {
+    it.each([
+      [{ name: 'Test' }, undefined],
+      [{ device_type: 'traffic' }, 'traffic'],
+    ])('handles device_type: %j -> %s', (input, expected) => {
+      const result = validateUpdateDevice(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.device_type).toBe(expected)
+    })
+
+    it.each([
+      [{ vendor: null }, null],
+      [{ vendor: '' }, null],
+      [{ vendor: 'Test Vendor' }, 'Test Vendor'],
+    ])('handles vendor: %j -> %s', (input, expected) => {
+      const result = validateUpdateDevice(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.vendor).toBe(expected)
+    })
+
+    it.each([
+      [{ config: { key: 'value' } }, '{"key":"value"}'],
+      [{ config: '{"key":"value"}' }, '{"key":"value"}'],
+      [{ config: null }, null],
+      [{ config: undefined }, undefined],
+      [{ name: 'Test' }, undefined],
+    ])('handles config: %j', (input, expected) => {
+      const result = validateUpdateDevice(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.config).toBe(expected)
+    })
+
+    it('handles all field types', () => {
+      const result = validateUpdateDevice({
+        name: 'Test',
+        device_type: 'traffic',
+        vendor: 'Vendor',
+        lat: 40.7128,
+        lng: -74.0060,
+        stream_url: 'https://example.com',
+        source_type: 'hls',
+        config: { key: 'value' },
+      })
+      expect(result.valid).toBe(true)
+      expect(result.data).toMatchObject({
+        name: 'Test',
+        device_type: 'traffic',
+        vendor: 'Vendor',
+        lat: 40.7128,
+        lng: -74.0060,
+        stream_url: 'https://example.com',
+        source_type: 'hls',
+        config: '{"key":"value"}',
+      })
+    })
+
+    it.each([
+      ['source_type'],
+      ['lat'],
+      ['lng'],
+      ['stream_url'],
+    ])('handles %s undefined in updates', (field) => {
       const result = validateUpdateDevice({ name: 'Test' })
       expect(result.valid).toBe(true)
-      expect(result.data.device_type).toBeUndefined()
-    })
-
-    it('handles vendor null', () => {
-      const result = validateUpdateDevice({ vendor: null })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBeNull()
-    })
-
-    it('handles vendor empty string', () => {
-      const result = validateUpdateDevice({ vendor: '' })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBeNull()
-    })
-
-    it('handles vendor string', () => {
-      const result = validateUpdateDevice({ vendor: 'Test Vendor' })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBe('Test Vendor')
+      expect(result.data[field]).toBeUndefined()
     })
   })
 
@@ -106,23 +172,13 @@ describe('validation', () => {
       expect(result.data.identifier).toBe('testuser')
     })
 
-    it('rejects missing identifier', () => {
-      const result = validateUser({
-        password: 'password123',
-        role: 'admin',
-      })
+    it.each([
+      [{ password: 'password123', role: 'admin' }, 'identifier required'],
+      [{ identifier: 'testuser', password: 'password123', role: 'invalid' }, 'role must be admin, leader, or member'],
+    ])('rejects invalid input: %j', (input, errorMsg) => {
+      const result = validateUser(input)
       expect(result.valid).toBe(false)
-      expect(result.errors).toContain('identifier required')
-    })
-
-    it('rejects invalid role', () => {
-      const result = validateUser({
-        identifier: 'testuser',
-        password: 'password123',
-        role: 'invalid',
-      })
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('role must be admin, leader, or member')
+      expect(result.errors).toContain(errorMsg)
     })
   })
 
@@ -138,6 +194,26 @@ describe('validation', () => {
       expect(result.valid).toBe(false)
       expect(result.errors).toContain('identifier cannot be empty')
     })
+
+    it.each([
+      [{ password: '' }, undefined],
+      [{ password: undefined }, undefined],
+      [{ password: 'newpassword' }, 'newpassword'],
+    ])('handles password: %j -> %s', (input, expected) => {
+      const result = validateUpdateUser(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.password).toBe(expected)
+    })
+
+    it.each([
+      ['role'],
+      ['identifier'],
+      ['password'],
+    ])('handles %s undefined', (field) => {
+      const result = validateUpdateUser({})
+      expect(result.valid).toBe(true)
+      expect(result.data[field]).toBeUndefined()
+    })
   })
 
   describe('validatePoi', () => {
@@ -149,31 +225,35 @@ describe('validation', () => {
         iconType: 'flag',
       })
       expect(result.valid).toBe(true)
-      expect(result.data.lat).toBe(40.7128)
+      expect(result.data).toMatchObject({
+        lat: 40.7128,
+        lng: -74.0060,
+        label: 'Test POI',
+        icon_type: 'flag',
+      })
     })
 
     it('rejects invalid coordinates', () => {
-      const result = validatePoi({
-        lat: 'invalid',
-        lng: -74.0060,
-      })
+      const result = validatePoi({ lat: 'invalid', lng: -74.0060 })
       expect(result.valid).toBe(false)
       expect(result.errors).toContain('lat and lng required as finite numbers')
     })
+
+    it.each([
+      [{ lat: 40.7128, lng: -74.0060 }, 'pin'],
+      [{ lat: 40.7128, lng: -74.0060, iconType: 'invalid' }, 'pin'],
+    ])('defaults iconType to pin: %j -> %s', (input, expected) => {
+      const result = validatePoi(input)
+      expect(result.valid).toBe(true)
+      expect(result.data.icon_type).toBe(expected)
+    })
   })
 
   describe('validateUpdatePoi', () => {
     it('validates partial updates', () => {
       const result = validateUpdatePoi({ label: 'Updated', lat: 40.7128 })
       expect(result.valid).toBe(true)
-      expect(result.data.label).toBe('Updated')
-      expect(result.data.lat).toBe(40.7128)
-    })
-
-    it('rejects invalid iconType', () => {
-      const result = validateUpdatePoi({ iconType: 'invalid' })
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('Invalid iconType')
+      expect(result.data).toMatchObject({ label: 'Updated', lat: 40.7128 })
     })
 
     it('allows empty updates', () => {
@@ -182,154 +262,16 @@ describe('validation', () => {
       expect(Object.keys(result.data).length).toBe(0)
     })
 
-    it('rejects invalid lat', () => {
-      const result = validateUpdatePoi({ lat: 'invalid' })
+    it.each([
+      [{ iconType: 'invalid' }, 'Invalid iconType'],
+      [{ lat: 'invalid' }, 'lat must be a finite number'],
+      [{ lng: 'invalid' }, 'lng must be a finite number'],
+    ])('rejects invalid input: %j', (input, errorMsg) => {
+      const result = validateUpdatePoi(input)
       expect(result.valid).toBe(false)
-      expect(result.errors).toContain('lat must be a finite number')
+      expect(result.errors).toContain(errorMsg)
     })
 
-    it('rejects invalid lng', () => {
-      const result = validateUpdatePoi({ lng: 'invalid' })
-      expect(result.valid).toBe(false)
-      expect(result.errors).toContain('lng must be a finite number')
-    })
-  })
-
-  describe('validateUpdateDevice', () => {
-    it('handles vendor null', () => {
-      const result = validateUpdateDevice({ vendor: null })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBeNull()
-    })
-
-    it('handles vendor empty string', () => {
-      const result = validateUpdateDevice({ vendor: '' })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBeNull()
-    })
-
-    it('handles config object', () => {
-      const result = validateUpdateDevice({ config: { key: 'value' } })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBe('{"key":"value"}')
-    })
-
-    it('handles config null', () => {
-      const result = validateUpdateDevice({ config: null })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBeNull()
-    })
-
-    it('handles config string', () => {
-      const result = validateUpdateDevice({ config: '{"key":"value"}' })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBe('{"key":"value"}')
-    })
-  })
-
-  describe('validateUpdateUser', () => {
-    it('handles empty password', () => {
-      const result = validateUpdateUser({ password: '' })
-      expect(result.valid).toBe(true)
-      expect(result.data.password).toBeUndefined()
-    })
-
-    it('handles undefined password', () => {
-      const result = validateUpdateUser({ password: undefined })
-      expect(result.valid).toBe(true)
-      expect(result.data.password).toBeUndefined()
-    })
-
-    it('validates password when provided', () => {
-      const result = validateUpdateUser({ password: 'newpassword' })
-      expect(result.valid).toBe(true)
-      expect(result.data.password).toBe('newpassword')
-    })
-  })
-
-  describe('validateDevice', () => {
-    it('handles missing stream_url', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.stream_url).toBe('')
-    })
-
-    it('handles invalid source_type', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
-        source_type: 'invalid',
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.source_type).toBe('mjpeg')
-    })
-  })
-
-  describe('validatePoi', () => {
-    it('defaults iconType to pin', () => {
-      const result = validatePoi({
-        lat: 40.7128,
-        lng: -74.0060,
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.icon_type).toBe('pin')
-    })
-
-    it('handles invalid iconType', () => {
-      const result = validatePoi({
-        lat: 40.7128,
-        lng: -74.0060,
-        iconType: 'invalid',
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.icon_type).toBe('pin')
-    })
-
-    it('validates valid POI with all fields', () => {
-      const result = validatePoi({
-        lat: 40.7128,
-        lng: -74.0060,
-        label: 'Test POI',
-        iconType: 'flag',
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.lat).toBe(40.7128)
-      expect(result.data.lng).toBe(-74.0060)
-      expect(result.data.label).toBe('Test POI')
-      expect(result.data.icon_type).toBe('flag')
-    })
-  })
-
-  describe('validateUpdateDevice', () => {
-    it('handles all field types', () => {
-      const result = validateUpdateDevice({
-        name: 'Test',
-        device_type: 'traffic',
-        vendor: 'Vendor',
-        lat: 40.7128,
-        lng: -74.0060,
-        stream_url: 'https://example.com',
-        source_type: 'hls',
-        config: { key: 'value' },
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.name).toBe('Test')
-      expect(result.data.device_type).toBe('traffic')
-      expect(result.data.vendor).toBe('Vendor')
-      expect(result.data.lat).toBe(40.7128)
-      expect(result.data.lng).toBe(-74.0060)
-      expect(result.data.stream_url).toBe('https://example.com')
-      expect(result.data.source_type).toBe('hls')
-      expect(result.data.config).toBe('{"key":"value"}')
-    })
-  })
-
-  describe('validateUpdatePoi', () => {
     it('handles all field types', () => {
       const result = validateUpdatePoi({
         label: 'Updated',
@@ -338,151 +280,23 @@ describe('validation', () => {
         lng: -75.0060,
       })
       expect(result.valid).toBe(true)
-      expect(result.data.label).toBe('Updated')
-      expect(result.data.icon_type).toBe('waypoint')
-      expect(result.data.lat).toBe(41.7128)
-      expect(result.data.lng).toBe(-75.0060)
-    })
-
-    it('handles partial updates', () => {
-      const result = validateUpdatePoi({ label: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.label).toBe('Test')
-    })
-  })
-
-  describe('validateDevice edge cases', () => {
-    it('handles vendor undefined', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
+      expect(result.data).toMatchObject({
+        label: 'Updated',
+        icon_type: 'waypoint',
+        lat: 41.7128,
+        lng: -75.0060,
       })
-      expect(result.valid).toBe(true)
-      expect(result.data.vendor).toBeNull()
     })
 
-    it('handles config as object', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
-        config: { key: 'value' },
-      })
+    it.each([
+      ['label'],
+      ['icon_type'],
+      ['lat'],
+      ['lng'],
+    ])('handles %s undefined', (field) => {
+      const result = validateUpdatePoi({})
       expect(result.valid).toBe(true)
-      expect(result.data.config).toBe('{"key":"value"}')
-    })
-
-    it('handles config as string', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
-        config: '{"key":"value"}',
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBe('{"key":"value"}')
-    })
-
-    it('handles config null', () => {
-      const result = validateDevice({
-        name: 'Test',
-        lat: 40.7128,
-        lng: -74.0060,
-        config: null,
-      })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBe(null)
-    })
-  })
-
-  describe('validateUpdateDevice edge cases', () => {
-    it('handles config null in updates', () => {
-      const result = validateUpdateDevice({ config: null })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBeNull()
-    })
-
-    it('handles config undefined in updates', () => {
-      const result = validateUpdateDevice({ config: undefined })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBeUndefined()
-    })
-
-    it('handles source_type undefined in updates', () => {
-      const result = validateUpdateDevice({ name: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.source_type).toBeUndefined()
-    })
-
-    it('handles lat undefined in updates', () => {
-      const result = validateUpdateDevice({ name: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.lat).toBeUndefined()
-    })
-
-    it('handles lng undefined in updates', () => {
-      const result = validateUpdateDevice({ name: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.lng).toBeUndefined()
-    })
-
-    it('handles stream_url undefined in updates', () => {
-      const result = validateUpdateDevice({ name: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.stream_url).toBeUndefined()
-    })
-
-    it('handles config undefined in updates', () => {
-      const result = validateUpdateDevice({ name: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.config).toBeUndefined()
-    })
-  })
-
-  describe('validateUpdateUser edge cases', () => {
-    it('handles role undefined', () => {
-      const result = validateUpdateUser({ identifier: 'test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.role).toBeUndefined()
-    })
-
-    it('handles identifier undefined', () => {
-      const result = validateUpdateUser({ role: 'admin' })
-      expect(result.valid).toBe(true)
-      expect(result.data.identifier).toBeUndefined()
-    })
-
-    it('handles password undefined', () => {
-      const result = validateUpdateUser({ role: 'admin' })
-      expect(result.valid).toBe(true)
-      expect(result.data.password).toBeUndefined()
-    })
-  })
-
-  describe('validateUpdatePoi edge cases', () => {
-    it('handles label undefined', () => {
-      const result = validateUpdatePoi({ lat: 40.7128 })
-      expect(result.valid).toBe(true)
-      expect(result.data.label).toBeUndefined()
-    })
-
-    it('handles iconType undefined', () => {
-      const result = validateUpdatePoi({ label: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.icon_type).toBeUndefined()
-    })
-
-    it('handles lat undefined', () => {
-      const result = validateUpdatePoi({ label: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.lat).toBeUndefined()
-    })
-
-    it('handles lng undefined', () => {
-      const result = validateUpdatePoi({ label: 'Test' })
-      expect(result.valid).toBe(true)
-      expect(result.data.lng).toBeUndefined()
+      expect(result.data[field]).toBeUndefined()
     })
   })
 })