@fmidev/smartmet-alert-client 4.2.7 → 4.7.0-alpha.0

package/tests/unit/mixins/config.spec.js

@@ -0,0 +1,269 @@
+import { describe, it, expect } from 'vitest'
+import { mount } from '@vue/test-utils'
+import config from '@/mixins/config'
+
+const TestComponent = {
+  mixins: [config],
+  template: '<div></div>',
+}
+
+describe('config mixin', () => {
+  let wrapper
+
+  beforeEach(() => {
+    wrapper = mount(TestComponent)
+  })
+
+  describe('Configuration constants', () => {
+    it('should define timezone', () => {
+      expect(wrapper.vm.timeZone).toBe('Europe/Helsinki')
+    })
+
+    it('should define date format locale', () => {
+      expect(wrapper.vm.dateTimeFormatLocale).toBe('fi-FI')
+    })
+
+    it('should define pan limits', () => {
+      expect(wrapper.vm.panLimits).toEqual({ x: 175, y: 275 })
+    })
+
+    it('should define coverage criterion', () => {
+      expect(wrapper.vm.coverageCriterion).toBe(0.2)
+    })
+
+    it('should define max merged weight', () => {
+      expect(wrapper.vm.maxMergedWeight).toBe(7)
+    })
+
+    it('should define max update delays', () => {
+      expect(wrapper.vm.maxUpdateDelay).toHaveProperty('weather_update_time')
+      expect(wrapper.vm.maxUpdateDelay).toHaveProperty('flood_update_time')
+      expect(wrapper.vm.maxUpdateDelay.weather_update_time).toBe(
+        12 * 60 * 60 * 1000
+      )
+    })
+  })
+
+  describe('Warning types map', () => {
+    it('should have warningTypes map', () => {
+      expect(wrapper.vm.warningTypes).toBeInstanceOf(Map)
+    })
+
+    it('should map land warning types', () => {
+      const landTypes = [
+        'thunderStorm',
+        'wind',
+        'rain',
+        'trafficWeather',
+        'pedestrianSafety',
+        'forestFireWeather',
+        'grassFireWeather',
+        'hotWeather',
+        'coldWeather',
+        'uvNote',
+        'floodLevel',
+      ]
+
+      landTypes.forEach((type) => {
+        expect(wrapper.vm.warningTypes.get(type)).toBe('land')
+      })
+    })
+
+    it('should map sea warning types', () => {
+      const seaTypes = [
+        'seaWind',
+        'seaThunderStorm',
+        'seaWaterHeightHighWater',
+        'seaWaterHeightShallowWater',
+        'seaWaveHeight',
+        'seaIcing',
+      ]
+
+      seaTypes.forEach((type) => {
+        expect(wrapper.vm.warningTypes.get(type)).toBe('sea')
+      })
+    })
+  })
+
+  describe('Region IDs', () => {
+    it('should have regionIds array', () => {
+      expect(Array.isArray(wrapper.vm.regionIds)).toBe(true)
+      expect(wrapper.vm.regionIds.length).toBeGreaterThan(0)
+    })
+
+    it('should include county regions', () => {
+      expect(wrapper.vm.regionIds).toContain('county.1')
+      expect(wrapper.vm.regionIds).toContain('county.2')
+    })
+
+    it('should include sea regions', () => {
+      expect(wrapper.vm.regionIds).toContain('sea_region.B1N')
+      expect(wrapper.vm.regionIds).toContain('sea_region.B2')
+    })
+
+    it('should include municipality regions', () => {
+      expect(wrapper.vm.regionIds).toContain('municipality.615')
+    })
+  })
+
+  describe('Geometries', () => {
+    it('should have geometries object', () => {
+      expect(wrapper.vm.geometries).toBeDefined()
+      expect(wrapper.vm.geometries).toHaveProperty('2021')
+    })
+
+    it('should have geometry data for counties', () => {
+      const county1 = wrapper.vm.geometries[2021]['county.1']
+
+      expect(county1).toBeDefined()
+      expect(county1).toHaveProperty('name')
+      expect(county1).toHaveProperty('type')
+      expect(county1).toHaveProperty('weight')
+      expect(county1).toHaveProperty('center')
+      expect(county1).toHaveProperty('pathLarge')
+      expect(county1).toHaveProperty('pathSmall')
+    })
+
+    it('should mark land regions correctly', () => {
+      const county = wrapper.vm.geometries[2021]['county.1']
+      expect(county.type).toBe('land')
+    })
+
+    it('should mark sea regions correctly', () => {
+      const seaRegion = wrapper.vm.geometries[2021]['sea_region.B1N']
+      expect(seaRegion.type).toBe('sea')
+    })
+
+    it('should have borders data', () => {
+      const borders = wrapper.vm.geometries[2021].borders
+
+      expect(borders).toBeDefined()
+      expect(borders).toHaveProperty('land')
+      expect(borders).toHaveProperty('sea')
+      expect(borders.land).toHaveProperty('pathLarge')
+      expect(borders.sea).toHaveProperty('pathLarge')
+    })
+
+    it('should include parent-child relationships', () => {
+      const municipality = wrapper.vm.geometries[2021]['municipality.615']
+
+      expect(municipality).toBeDefined()
+      expect(municipality).toHaveProperty('parent')
+      expect(municipality.parent).toBe('county.17')
+    })
+  })
+
+  describe('Colors configuration', () => {
+    it('should have colors for all themes', () => {
+      expect(wrapper.vm.colors).toHaveProperty('light-theme')
+      expect(wrapper.vm.colors).toHaveProperty('dark-theme')
+      expect(wrapper.vm.colors).toHaveProperty('light-gray-theme')
+      expect(wrapper.vm.colors).toHaveProperty('dark-gray-theme')
+    })
+
+    it('should define severity levels colors', () => {
+      const lightTheme = wrapper.vm.colors['light-theme']
+
+      expect(lightTheme.levels).toHaveLength(5)
+      expect(lightTheme).toHaveProperty('sea')
+      expect(lightTheme).toHaveProperty('missing')
+      expect(lightTheme).toHaveProperty('stroke')
+    })
+
+    it('should have different colors for gray themes', () => {
+      const lightTheme = wrapper.vm.colors['light-theme']
+      const grayTheme = wrapper.vm.colors['light-gray-theme']
+
+      expect(lightTheme.levels).not.toEqual(grayTheme.levels)
+    })
+  })
+
+  describe('Warning icon method', () => {
+    it('should generate wind icon with direction', () => {
+      const warning = {
+        type: 'wind',
+        direction: 90,
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon).toHaveProperty('aspectRatio')
+      expect(icon).toHaveProperty('geom')
+      expect(icon.geom).toContain('wind-symbol')
+    })
+
+    it('should generate thunder storm icon', () => {
+      const warning = {
+        type: 'thunderStorm',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('thunder-symbol')
+    })
+
+    it('should generate rain icon', () => {
+      const warning = {
+        type: 'rain',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('rain-symbol')
+    })
+
+    it('should generate traffic weather icon', () => {
+      const warning = {
+        type: 'trafficWeather',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('traffic-symbol')
+    })
+
+    it('should generate sea wind icon with text', () => {
+      const warning = {
+        type: 'seaWind',
+        direction: 180,
+        text: '15',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('seawind-symbol')
+      expect(icon.geom).toContain('15')
+    })
+
+    it('should generate flood icon based on severity', () => {
+      const warning = {
+        type: 'floodLevel',
+        severity: 3,
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('flood-level-3')
+    })
+
+    it('should generate multiple warnings icon', () => {
+      const warning = {
+        type: 'multiple',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.geom).toContain('multiple-symbol')
+    })
+
+    it('should set scale for specific warning types', () => {
+      const warning = {
+        type: 'hotWeather',
+      }
+
+      const icon = wrapper.vm.warningIcon(warning)
+
+      expect(icon.scale).toBe(1.2)
+    })
+  })
+})

package/tests/unit/mixins/i18n.spec.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest'
+import { mount } from '@vue/test-utils'
+import i18n from '@/mixins/i18n'
+
+const TestComponent = {
+  mixins: [i18n],
+  template: '<div>{{ t("noWarnings") }}</div>',
+  props: {
+    language: {
+      type: String,
+      default: 'fi',
+    },
+  },
+}
+
+describe('i18n mixin', () => {
+  describe('t() method', () => {
+    it('should return Finnish translation', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      const result = wrapper.vm.t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return English translation', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'en' },
+      })
+
+      const result = wrapper.vm.t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return Swedish translation', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'sv' },
+      })
+
+      const result = wrapper.vm.t('noWarnings')
+      expect(result).toBeTruthy()
+      expect(typeof result).toBe('string')
+    })
+
+    it('should return empty string for unknown language', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'de' },
+      })
+
+      const result = wrapper.vm.t('noWarnings')
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for null key', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      const result = wrapper.vm.t(null)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for undefined key', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      const result = wrapper.vm.t(undefined)
+      expect(result).toBe('')
+    })
+
+    it('should return empty string for non-existent key', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      const result = wrapper.vm.t('nonExistentKey12345')
+      expect(result).toBe('')
+    })
+
+    it('should sanitize HTML in translations', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      // Assuming translations don't contain scripts
+      const result = wrapper.vm.t('noWarnings')
+      expect(result).not.toContain('<script>')
+      expect(result).not.toContain('javascript:')
+    })
+
+    it('should handle all common translation keys', () => {
+      const wrapper = mount(TestComponent, {
+        props: { language: 'fi' },
+      })
+
+      const commonKeys = [
+        'noWarnings',
+        'validWarnings',
+        'toContent',
+        'supportedBrowsers',
+        'floodLink',
+        'floodLinkText',
+      ]
+
+      commonKeys.forEach((key) => {
+        const result = wrapper.vm.t(key)
+        expect(typeof result).toBe('string')
+      })
+    })
+  })
+})

package/tests/unit/mixins/keycodes.spec.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest'
+import { mount } from '@vue/test-utils'
+import keycodes from '@/mixins/keycodes'
+
+const TestComponent = {
+  mixins: [keycodes],
+  template: '<div></div>',
+}
+
+describe('keycodes mixin', () => {
+  it('should define KEY_CODE_END', () => {
+    const wrapper = mount(TestComponent)
+    expect(wrapper.vm.KEY_CODE_END).toBe(35)
+  })
+
+  it('should define KEY_CODE_HOME', () => {
+    const wrapper = mount(TestComponent)
+    expect(wrapper.vm.KEY_CODE_HOME).toBe(36)
+  })
+
+  it('should define KEY_CODE_LEFT', () => {
+    const wrapper = mount(TestComponent)
+    expect(wrapper.vm.KEY_CODE_LEFT).toBe(37)
+  })
+
+  it('should define KEY_CODE_RIGHT', () => {
+    const wrapper = mount(TestComponent)
+    expect(wrapper.vm.KEY_CODE_RIGHT).toBe(39)
+  })
+
+  it('should have all arrow key codes', () => {
+    const wrapper = mount(TestComponent)
+
+    expect(wrapper.vm.KEY_CODE_LEFT).toBeLessThan(wrapper.vm.KEY_CODE_RIGHT)
+    expect(wrapper.vm.KEY_CODE_HOME).toBeLessThan(wrapper.vm.KEY_CODE_RIGHT)
+  })
+})