@fmidev/smartmet-alert-client 4.4.19 → 4.7.0-beta.0

package/tests/integration/warning-flow.spec.ts

@@ -0,0 +1,445 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { mockWarningsData } from '../fixtures/mockWarningData'
+import {
+  processWarnings,
+  type WarningsProcessorContext,
+} from '@/composables/useWarningsProcessor'
+import { useConfig } from '@/composables/useConfig'
+import { useI18n } from '@/composables/useI18n'
+import geojsonsvg from '@/mixins/geojsonsvg'
+import type { WarningsData } from '@/types'
+
+// Bind all methods so 'this' works correctly when called standalone
+const geoJSONToSVG = geojsonsvg.methods.geoJSONToSVG.bind(geojsonsvg.methods)
+
+describe('Warning data flow integration', () => {
+  let config: ReturnType<typeof useConfig>
+  let ctx: WarningsProcessorContext
+
+  beforeEach(() => {
+    config = useConfig()
+    const { t } = useI18n('fi')
+
+    // Create a context object that processWarnings needs
+    ctx = {
+      geometryId: '2021',
+      geometries: config.geometries,
+      warningTypes: config.warningTypes,
+      regionIds: config.regionIds,
+      dailyWarningTypes: [],
+      currentTime: new Date('2025-10-31T12:00:00Z').getTime(),
+      startFrom: '',
+      staticDays: true,
+      timeZone: config.timeZone,
+      locale: config.dateTimeFormatLocale,
+      bbox: config.bbox as WarningsProcessorContext['bbox'],
+      geoJSONToSVG,
+      maxUpdateDelay:
+        config.maxUpdateDelay as WarningsProcessorContext['maxUpdateDelay'],
+      t,
+      handleError: () => {
+        // Mock error handler - does nothing in tests
+      },
+      onDataError: () => {
+        // Mock data error handler - does nothing in tests
+      },
+    }
+  })
+
+  describe('Complete warning processing', () => {
+    it('should process full warning dataset', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      expect(result).toHaveProperty('warnings')
+      expect(result).toHaveProperty('days')
+      expect(result).toHaveProperty('regions')
+      expect(result).toHaveProperty('parents')
+      expect(result).toHaveProperty('legend')
+    })
+
+    it('should create 5 days from warnings', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      expect(result.days).toHaveLength(5)
+      result.days.forEach((day) => {
+        expect(day).toHaveProperty('weekdayName')
+        expect(day).toHaveProperty('day')
+        expect(day).toHaveProperty('month')
+        expect(day).toHaveProperty('year')
+        expect(day).toHaveProperty('severity')
+        expect(day).toHaveProperty('updatedDate')
+        expect(day).toHaveProperty('updatedTime')
+      })
+    })
+
+    it('should parse weather warnings correctly', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const windWarning = result.warnings['test-warning-wind-1']
+      expect(windWarning).toBeDefined()
+      expect(windWarning!.type).toBe('wind')
+      expect(windWarning!.severity).toBe(3)
+    })
+
+    it('should parse flood warnings correctly', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const floodWarning = result.warnings['test-warning-flood-1']
+      expect(floodWarning).toBeDefined()
+      expect(floodWarning!.type).toBe('floodLevel')
+      expect(floodWarning!.severity).toBe(3)
+    })
+
+    it('should create legend sorted by severity', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      expect(result.legend.length).toBeGreaterThan(0)
+
+      // Check that legend is sorted by severity (descending)
+      for (let i = 0; i < result.legend.length - 1; i++) {
+        expect(result.legend[i]!.severity).toBeGreaterThanOrEqual(
+          result.legend[i + 1]!.severity
+        )
+      }
+    })
+
+    it('should create regions with warnings', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      expect(result.regions).toHaveLength(5)
+      result.regions.forEach((day) => {
+        expect(day).toHaveProperty('land')
+        expect(day).toHaveProperty('sea')
+        expect(Array.isArray(day.land)).toBe(true)
+        expect(Array.isArray(day.sea)).toBe(true)
+      })
+    })
+
+    it('should handle missing weather data gracefully', () => {
+      const incompleteData = {
+        weather_update_time: mockWarningsData.weather_update_time,
+        flood_update_time: mockWarningsData.flood_update_time,
+        // Missing weather and flood warnings
+      } as WarningsData
+
+      const result = processWarnings(incompleteData, ctx)
+      expect(result).toBeDefined()
+    })
+
+    it('should set updatedAt timestamp', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      expect(result.updatedAt).toBeDefined()
+      expect(typeof result.updatedAt).toBe('number')
+      expect(result.updatedAt).toBeGreaterThan(0)
+    })
+
+    it('should filter out invalid warnings', () => {
+      const dataWithInvalid = {
+        ...mockWarningsData,
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            ...mockWarningsData.weather_finland_active_all!.features,
+            {
+              type: 'Feature' as const,
+              properties: {
+                identifier: 'invalid-warning',
+                warning_context: 'wind',
+                severity: 'level-1', // Invalid for wind
+                effective_from: '2025-10-31T12:00:00Z',
+                effective_until: '2025-11-01T12:00:00Z',
+                reference: 'fi-warning#county.1',
+              },
+              geometry: null,
+            },
+          ],
+        },
+      } as WarningsData
+
+      const result = processWarnings(dataWithInvalid, ctx)
+
+      expect(result.warnings).not.toHaveProperty('invalid-warning')
+    })
+  })
+
+  describe('Region hierarchy', () => {
+    it('should handle parent-child relationships', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      // Check that parents object is created
+      expect(result.parents).toBeDefined()
+      expect(typeof result.parents).toBe('object')
+    })
+  })
+
+  describe('Coverage handling', () => {
+    it('should process coverage data when present', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const coverageWarning = result.warnings['test-warning-coverage-1']
+      if (coverageWarning) {
+        expect(coverageWarning.covRegions).toBeInstanceOf(Map)
+      }
+    })
+  })
+
+  describe('Multi-language support', () => {
+    it('should include info in all languages for weather warnings', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const windWarning = result.warnings['test-warning-wind-1']
+      expect(windWarning!.info).toHaveProperty('fi')
+      expect(windWarning!.info).toHaveProperty('sv')
+      expect(windWarning!.info).toHaveProperty('en')
+    })
+
+    it('should decode HTML entities in warning info', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const windWarning = result.warnings['test-warning-wind-1']
+      // HTML entities should be decoded by he.decode
+      expect(windWarning!.info.fi).not.toContain('&amp;')
+      expect(windWarning!.info.fi).not.toContain('&lt;')
+    })
+  })
+
+  describe('Time calculations', () => {
+    it('should calculate effective days correctly', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const windWarning = result.warnings['test-warning-wind-1']
+      expect(windWarning!.effectiveDays).toHaveLength(5)
+      expect(windWarning!.effectiveDays.some((day) => day === true)).toBe(true)
+    })
+
+    it('should format valid intervals correctly', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const windWarning = result.warnings['test-warning-wind-1']
+      expect(windWarning!.validInterval).toContain('–')
+      expect(windWarning!.validInterval).toMatch(/\d{1,2}\.\d{1,2}\./)
+    })
+  })
+
+  describe('Severity calculations', () => {
+    it('should calculate day severities from warnings', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      const firstDay = result.days[0]
+      // Should have severity based on active warnings
+      expect(typeof firstDay!.severity).toBe('number')
+      expect(firstDay!.severity).toBeGreaterThanOrEqual(0)
+      expect(firstDay!.severity).toBeLessThanOrEqual(4)
+    })
+
+    it('should show highest severity per day', () => {
+      const result = processWarnings(mockWarningsData, ctx)
+
+      // Check that severity is the max of all warnings for that day
+      result.days.forEach((day, dayIndex) => {
+        const warningsForDay = Object.values(result.warnings).filter(
+          (warning) => warning.effectiveDays[dayIndex]
+        )
+
+        if (warningsForDay.length > 0) {
+          const maxSeverity = Math.max(...warningsForDay.map((w) => w.severity))
+          expect(day.severity).toBe(maxSeverity)
+        } else {
+          expect(day.severity).toBe(0)
+        }
+      })
+    })
+  })
+
+  describe('Edge cases and error handling', () => {
+    it('should handle warnings with some missing properties', () => {
+      const incompleteData = {
+        weather_update_time: '2025-10-31T12:00:00Z',
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            {
+              type: 'Feature' as const,
+              properties: {
+                identifier: 'incomplete-warning',
+                warning_context: 'wind',
+                severity: 'level-2',
+                effective_from: '2025-10-31T12:00:00Z',
+                effective_until: '2025-11-01T12:00:00Z',
+                reference: 'fi-warning#county.1',
+                // Missing descriptions, but has essential properties
+              },
+              geometry: {
+                type: 'Point' as const,
+                coordinates: [25.0, 60.0] as [number, number],
+              },
+            },
+          ],
+        },
+      } as unknown as WarningsData
+
+      const result = processWarnings(incompleteData, ctx)
+
+      // Should process the warning even with missing descriptions
+      expect(result).toBeDefined()
+      expect(result.warnings).toBeDefined()
+    })
+
+    it('should handle malformed timestamps', () => {
+      const badTimestampData = {
+        weather_update_time: 'invalid-timestamp',
+        flood_update_time: 'also-invalid',
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [],
+        },
+      } as unknown as WarningsData
+
+      const result = processWarnings(badTimestampData, ctx)
+      expect(result).toBeDefined()
+      expect(result.days).toHaveLength(5)
+    })
+
+    it('should handle circular references in region hierarchy', () => {
+      const dataWithCircular = {
+        ...mockWarningsData,
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: mockWarningsData.weather_finland_active_all!.features.map(
+            (f) => ({
+              ...f,
+              properties: {
+                ...f.properties,
+                // Create potential circular reference
+                reference: f.properties.identifier,
+              },
+            })
+          ),
+        },
+      } as WarningsData
+
+      expect(() => {
+        processWarnings(dataWithCircular, ctx)
+      }).not.toThrow()
+    })
+
+    it('should handle very long warning descriptions', () => {
+      const longDescription = 'A'.repeat(10000)
+      const dataWithLongText = {
+        ...mockWarningsData,
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            {
+              ...mockWarningsData.weather_finland_active_all!.features[0],
+              properties: {
+                ...mockWarningsData.weather_finland_active_all!.features[0]!
+                  .properties,
+                description_fi: longDescription,
+                description_sv: longDescription,
+                description_en: longDescription,
+              },
+            },
+          ],
+        },
+      } as WarningsData
+
+      const result = processWarnings(dataWithLongText, ctx)
+      expect(result).toBeDefined()
+      expect(result.warnings).toBeDefined()
+    })
+
+    it('should handle warnings spanning across midnight', () => {
+      const midnightData = {
+        weather_update_time: '2025-10-31T23:00:00Z',
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            {
+              type: 'Feature' as const,
+              properties: {
+                identifier: 'midnight-warning',
+                warning_context: 'wind',
+                severity: 'level-2',
+                effective_from: '2025-10-31T23:30:00Z',
+                effective_until: '2025-11-01T01:30:00Z',
+                reference: 'fi-warning#county.1',
+                description_fi: 'Kova tuuli',
+                description_sv: 'Hårt väder',
+                description_en: 'Strong wind',
+              },
+              geometry: {
+                type: 'Point' as const,
+                coordinates: [25.0, 60.0] as [number, number],
+              },
+            },
+          ],
+        },
+      } as unknown as WarningsData
+
+      const result = processWarnings(midnightData, ctx)
+      expect(result.warnings['midnight-warning']).toBeDefined()
+      expect(result.warnings['midnight-warning']!.effectiveDays).toBeDefined()
+    })
+
+    it('should handle duplicate warning identifiers', () => {
+      const duplicateData = {
+        weather_update_time: '2025-10-31T12:00:00Z',
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            mockWarningsData.weather_finland_active_all!.features[0],
+            mockWarningsData.weather_finland_active_all!.features[0], // Duplicate
+          ],
+        },
+      } as unknown as WarningsData
+
+      const result = processWarnings(duplicateData, ctx)
+
+      // Should handle duplicates gracefully
+      expect(result).toBeDefined()
+      expect(Object.keys(result.warnings).length).toBeGreaterThan(0)
+    })
+
+    it('should handle special characters in warning text', () => {
+      const specialCharsData = {
+        weather_update_time: '2025-10-31T12:00:00Z',
+        weather_finland_active_all: {
+          type: 'FeatureCollection' as const,
+          features: [
+            {
+              type: 'Feature' as const,
+              properties: {
+                identifier: 'special-chars-warning',
+                warning_context: 'wind',
+                severity: 'level-2',
+                effective_from: '2025-10-31T12:00:00Z',
+                effective_until: '2025-11-01T12:00:00Z',
+                reference: 'fi-warning#county.1',
+                description_fi:
+                  'Test &lt;script&gt;alert("xss")&lt;/script&gt; &amp; special chars',
+                description_sv:
+                  'Test &lt;script&gt;alert("xss")&lt;/script&gt; &amp; special chars',
+                description_en:
+                  'Test &lt;script&gt;alert("xss")&lt;/script&gt; &amp; special chars',
+              },
+              geometry: {
+                type: 'Point' as const,
+                coordinates: [25.0, 60.0] as [number, number],
+              },
+            },
+          ],
+        },
+      } as unknown as WarningsData
+
+      const result = processWarnings(specialCharsData, ctx)
+      const warning = result.warnings['special-chars-warning']
+
+      // HTML entities should be decoded
+      expect(warning!.info.fi).not.toContain('&lt;')
+      expect(warning!.info.fi).not.toContain('&gt;')
+      expect(warning!.info.fi).not.toContain('&amp;')
+    })
+  })
+})

package/tests/setup.ts

@@ -0,0 +1,41 @@
+import { vi } from 'vitest'
+import '@testing-library/jest-dom'
+import { config } from '@vue/test-utils'
+
+// Mock environment variables
+process.env.VITE_LANGUAGE = 'fi'
+
+// Configure global stubs for components
+config.global.stubs = {
+  GrayScaleToggle: true,
+  CollapsiblePanel: true,
+}
+
+// Mock window.getComputedStyle
+global.window.getComputedStyle = vi.fn(() => ({
+  fontSize: '16px',
+})) as unknown as typeof window.getComputedStyle
+
+// Mock IntersectionObserver
+global.IntersectionObserver = class IntersectionObserver {
+  constructor() {}
+  disconnect() {}
+  observe() {}
+  takeRecords(): IntersectionObserverEntry[] {
+    return []
+  }
+  unobserve() {}
+} as unknown as typeof IntersectionObserver
+
+// Mock ResizeObserver
+global.ResizeObserver = class ResizeObserver {
+  constructor() {}
+  disconnect() {}
+  observe() {}
+  unobserve() {}
+} as unknown as typeof ResizeObserver
+
+// Mock fetch if not available
+if (!global.fetch) {
+  global.fetch = vi.fn() as unknown as typeof fetch
+}