@i18n-micro/core 1.0.27 → 1.1.0

package/tests/base.test.ts

@@ -0,0 +1,485 @@
+import { BaseI18n, type BaseI18nOptions } from '../src/base'
+import type { Translations, PluralFunc } from '@i18n-micro/types'
+
+// Test implementation of BaseI18n
+class TestI18n extends BaseI18n {
+  private _locale: string
+  private _fallbackLocale: string
+  private _route: string
+
+  constructor(
+    locale: string,
+    fallbackLocale: string,
+    route: string,
+    options?: BaseI18nOptions,
+  ) {
+    super(options)
+    this._locale = locale
+    this._fallbackLocale = fallbackLocale
+    this._route = route
+  }
+
+  public getLocale(): string {
+    return this._locale
+  }
+
+  public getFallbackLocale(): string {
+    return this._fallbackLocale
+  }
+
+  public getRoute(): string {
+    return this._route
+  }
+
+  public setLocale(locale: string): void {
+    this._locale = locale
+  }
+
+  public setRoute(route: string): void {
+    this._route = route
+  }
+}
+
+describe('BaseI18n', () => {
+  describe('Constructor', () => {
+    test('should initialize with default options', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.getLocale()).toBe('en')
+      expect(i18n.getFallbackLocale()).toBe('en')
+      expect(i18n.getRoute()).toBe('general')
+    })
+
+    test('should initialize with custom storage', () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
+      expect(i18n).toBeDefined()
+    })
+
+    test('should initialize with custom plural function', () => {
+      const customPlural: PluralFunc = () => 'custom'
+      const i18n = new TestI18n('en', 'en', 'general', { plural: customPlural })
+      expect(i18n).toBeDefined()
+    })
+
+    test('should initialize with missingWarn option', () => {
+      const i18n = new TestI18n('en', 'en', 'general', { missingWarn: false })
+      expect(i18n).toBeDefined()
+    })
+
+    test('should initialize with missingHandler', () => {
+      const handler = jest.fn()
+      const i18n = new TestI18n('en', 'en', 'general', { missingHandler: handler })
+      expect(i18n).toBeDefined()
+    })
+  })
+
+  describe('t() method', () => {
+    test('should return empty string for empty key', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.t('')).toBe('')
+    })
+
+    test('should return translation for existing key', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { greeting: 'Hello' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.t('greeting')).toBe('Hello')
+    })
+
+    test('should interpolate params in translation', async () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
+      const translations: Translations = { greeting: 'Hello, {name}!' }
+      await i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.t('greeting', { name: 'John' })).toBe('Hello, John!')
+    })
+
+    test('should use defaultValue when translation is missing', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.t('missing.key', undefined, 'Default value')).toBe('Default value')
+    })
+
+    test('should return key when translation is missing and no defaultValue', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.t('missing.key')).toBe('missing.key')
+    })
+
+    test('should fallback to fallbackLocale when translation is missing', async () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'fr', 'general', { storage })
+      const translations: Translations = { greeting: 'Bonjour' }
+      await i18n['helper'].loadTranslations('fr', translations)
+
+      expect(i18n.t('greeting')).toBe('Bonjour')
+    })
+
+    test('should use route-specific translation when routeName is provided', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const routeTranslations: Translations = { title: 'Route Title' }
+      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
+
+      expect(i18n.t('title', undefined, undefined, 'about')).toBe('Route Title')
+    })
+
+    test('should use previousPageInfo fallback when enabled', async () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const prevInfo = { locale: 'fr', routeName: 'previous' }
+      const i18n = new TestI18n('en', 'en', 'general', {
+        storage,
+        getPreviousPageInfo: () => prevInfo,
+        enablePreviousPageFallback: true,
+      })
+
+      const translations: Translations = { greeting: 'Bonjour' }
+      await i18n['helper'].loadPageTranslations('fr', 'previous', translations)
+
+      // Current locale is 'en', route is 'general', translation not found
+      // Should fallback to previous page info: locale 'fr', route 'previous'
+      expect(i18n.t('greeting')).toBe('Bonjour')
+    })
+
+    test('should call missingHandler when translation is missing', () => {
+      const handler = jest.fn()
+      const i18n = new TestI18n('en', 'en', 'general', { missingHandler: handler })
+
+      i18n.t('missing.key')
+
+      expect(handler).toHaveBeenCalledWith('en', 'missing.key', 'general')
+    })
+
+    test('should call customMissingHandler when set (Nuxt runtime)', () => {
+      const customHandler = jest.fn()
+      const i18n = new TestI18n('en', 'en', 'general', {
+        getCustomMissingHandler: () => customHandler,
+      })
+
+      i18n.t('missing.key')
+
+      expect(customHandler).toHaveBeenCalledWith('en', 'missing.key', 'general')
+    })
+
+    test('should not warn when missingWarn is false', () => {
+      const consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+      const i18n = new TestI18n('en', 'en', 'general', { missingWarn: false })
+
+      i18n.t('missing.key')
+
+      expect(consoleSpy).not.toHaveBeenCalled()
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('ts() method', () => {
+    test('should return translation as string', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { greeting: 'Hello' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.ts('greeting')).toBe('Hello')
+    })
+
+    test('should return defaultValue when translation is missing', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.ts('missing.key', undefined, 'Default')).toBe('Default')
+    })
+
+    test('should return key when translation is missing and no defaultValue', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.ts('missing.key')).toBe('missing.key')
+    })
+
+    test('should convert non-string values to string', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { count: 42 }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.ts('count')).toBe('42')
+    })
+  })
+
+  describe('tc() method', () => {
+    test('should return defaultValue when count is undefined', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.tc('apples', { other: 'params' }, 'No count')).toBe('No count')
+    })
+
+    test('should use plural function with count', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { apples: 'apple|apples' }
+      await i18n['helper'].loadTranslations('en', translations)
+
+      // defaultPlural selects form by index: forms[count] or last form if count >= forms.length
+      // For 'apple|apples': forms[0]='apple', forms[1]='apples'
+      expect(i18n.tc('apples', 0)).toBe('apple')
+      expect(i18n.tc('apples', 1)).toBe('apples') // forms[1]
+      expect(i18n.tc('apples', 5)).toBe('apples') // last form
+    })
+
+    test('should handle count as number', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { apples: 'apple|apples' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.tc('apples', 2)).toBe('apples')
+    })
+
+    test('should handle count as Params object', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { apples: 'apple|apples' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.tc('apples', { count: 2, name: 'John' })).toBe('apples')
+    })
+
+    test('should return defaultValue when plural function returns null', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      // When translation is missing, t() returns key, which is passed to pluralFunc
+      // pluralFunc tries to process 'missing.key' as translation, but since it doesn't contain '|',
+      // it returns the key itself. So tc returns the key, not defaultValue.
+      // To test defaultValue, we need a case where pluralFunc actually returns null.
+      // This happens when translation exists but is empty or invalid.
+      expect(i18n.tc('missing.key', 1, 'Default')).toBe('missing.key')
+    })
+  })
+
+  describe('tn() method', () => {
+    test('should format number with default locale', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const result = i18n.tn(1234.56)
+      expect(result).toMatch(/1[,.]234[.,]56/)
+    })
+
+    test('should format number with custom options', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const result = i18n.tn(1234.56, { style: 'currency', currency: 'USD' })
+      expect(result).toContain('1,234.56')
+    })
+
+    test('should use current locale for formatting', () => {
+      const i18n = new TestI18n('ru', 'en', 'general')
+      const result = i18n.tn(1234.56)
+      // Russian locale uses different number formatting
+      expect(result).toBeDefined()
+    })
+  })
+
+  describe('td() method', () => {
+    test('should format date with default locale', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const date = new Date('2024-01-15')
+      const result = i18n.td(date)
+      expect(result).toBeDefined()
+      expect(result).not.toBe('Invalid Date')
+    })
+
+    test('should format date with custom options', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const date = new Date('2024-01-15')
+      const result = i18n.td(date, { year: 'numeric', month: 'long', day: 'numeric' })
+      expect(result).toContain('2024')
+      expect(result).toContain('January')
+    })
+
+    test('should handle date as number (timestamp)', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const timestamp = new Date('2024-01-15').getTime()
+      const result = i18n.td(timestamp)
+      expect(result).toBeDefined()
+      expect(result).not.toBe('Invalid Date')
+    })
+
+    test('should handle date as string', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const result = i18n.td('2024-01-15')
+      expect(result).toBeDefined()
+      expect(result).not.toBe('Invalid Date')
+    })
+  })
+
+  describe('tdr() method', () => {
+    test('should format relative time', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const yesterday = new Date(Date.now() - 86400000)
+      const result = i18n.tdr(yesterday)
+      expect(result).toBeDefined()
+      expect(result).toMatch(/day|ago/i)
+    })
+
+    test('should format relative time with custom options', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const yesterday = new Date(Date.now() - 86400000)
+      const result = i18n.tdr(yesterday, { numeric: 'always' })
+      expect(result).toBeDefined()
+    })
+
+    test('should handle invalid date gracefully', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const invalidDate = new Date('invalid')
+      const result = i18n.tdr(invalidDate)
+      expect(result).toBeDefined()
+    })
+  })
+
+  describe('has() method', () => {
+    test('should return true when translation exists', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { greeting: 'Hello' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.has('greeting')).toBe(true)
+    })
+
+    test('should return false when translation does not exist', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.has('missing.key')).toBe(false)
+    })
+
+    test('should check route-specific translation when routeName is provided', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const routeTranslations: Translations = { title: 'Route Title' }
+      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
+
+      expect(i18n.has('title', 'about')).toBe(true)
+      expect(i18n.has('title', 'general')).toBe(false)
+    })
+
+    test('should use current route when routeName is not provided', async () => {
+      const i18n = new TestI18n('en', 'en', 'about')
+      const routeTranslations: Translations = { title: 'Route Title' }
+      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
+
+      expect(i18n.has('title')).toBe(true)
+    })
+  })
+
+  describe('clearCache() method', () => {
+    test('should clear all translations from cache', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { greeting: 'Hello' }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.has('greeting')).toBe(true)
+
+      i18n.clearCache()
+
+      expect(i18n.has('greeting')).toBe(false)
+    })
+  })
+
+  describe('loadTranslationsCore() method', () => {
+    test('should load translations when merge is false', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { greeting: 'Hello' }
+
+      i18n['loadTranslationsCore']('en', translations, false)
+      // Wait for async operation to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      expect(i18n.has('greeting')).toBe(true)
+    })
+
+    test('should merge translations when merge is true', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const initial: Translations = { greeting: 'Hello' }
+      const additional: Translations = { farewell: 'Goodbye' }
+
+      await i18n['helper'].loadTranslations('en', initial)
+      i18n['loadTranslationsCore']('en', additional, true)
+      // Wait for async operation to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      expect(i18n.has('greeting')).toBe(true)
+      expect(i18n.has('farewell')).toBe(true)
+    })
+  })
+
+  describe('loadRouteTranslationsCore() method', () => {
+    test('should load route translations when merge is false', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = { title: 'Page Title' }
+
+      i18n['loadRouteTranslationsCore']('en', 'about', translations, false)
+      // Wait for async operation to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      expect(i18n.has('title', 'about')).toBe(true)
+    })
+
+    test('should merge route translations when merge is true', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const initial: Translations = { title: 'Page Title' }
+      const additional: Translations = { description: 'Page Description' }
+
+      await i18n['helper'].loadPageTranslations('en', 'about', initial)
+      i18n['loadRouteTranslationsCore']('en', 'about', additional, true)
+      // Wait for async operation to complete
+      await new Promise(resolve => setTimeout(resolve, 0))
+
+      expect(i18n.has('title', 'about')).toBe(true)
+      expect(i18n.has('description', 'about')).toBe(true)
+    })
+  })
+
+  describe('Edge cases', () => {
+    test('should handle nested translation keys', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = {
+        nested: {
+          deep: {
+            key: 'Nested value',
+          },
+        },
+      }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.t('nested.deep.key')).toBe('Nested value')
+    })
+
+    test('should handle multiple params in interpolation', async () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      const translations: Translations = {
+        message: 'Hello, {name}! You are {age} years old.',
+      }
+      i18n['helper'].loadTranslations('en', translations)
+
+      expect(i18n.t('message', { name: 'John', age: 30 })).toBe('Hello, John! You are 30 years old.')
+    })
+
+    test('should handle null defaultValue', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      expect(i18n.t('missing.key', undefined, null)).toBe('missing.key')
+    })
+
+    test('should handle empty string defaultValue', () => {
+      const i18n = new TestI18n('en', 'en', 'general')
+      // Empty string is falsy, so it will fall back to key (as per defaultValue || key logic)
+      expect(i18n.t('missing.key', undefined, '')).toBe('missing.key')
+    })
+
+    test('should handle route change', async () => {
+      const storage = { translations: new Map<string, Translations>() }
+      const i18n = new TestI18n('en', 'en', 'general', { storage })
+      const generalTranslations: Translations = { greeting: 'Hello' }
+      const routeTranslations: Translations = { title: 'About Page' }
+
+      await i18n['helper'].loadTranslations('en', generalTranslations)
+      await i18n['helper'].loadPageTranslations('en', 'about', routeTranslations)
+
+      // Verify translations are loaded
+      expect(i18n.has('greeting')).toBe(true)
+      expect(i18n.has('title', 'about')).toBe(true)
+
+      // Check route-specific translation with explicit routeName
+      // Note: getTranslation uses routeName parameter, so this should work
+      const titleValue = i18n.t('title', undefined, undefined, 'about')
+      expect(titleValue).toBe('About Page')
+
+      // Change route and check
+      i18n.setRoute('about')
+      expect(i18n.t('title')).toBe('About Page')
+      expect(i18n.t('greeting')).toBe('Hello') // Should still work from general
+    })
+  })
+})

package/tests/route-service.test.ts

@@ -13,7 +13,6 @@ describe('RouteService', () => {
   let routeService: RouteService
   let mockRouter: jest.Mocked<Router>
   let mockI18nConfig: ModuleOptionsExtend
-  let setCookieMock: jest.Mock
   let navigateToMock: jest.Mock
 
   beforeEach(() => {
@@ -47,20 +46,15 @@ describe('RouteService', () => {
       hashMode: false,
     }
 
-    // Mock setCookie and navigateTo
-    setCookieMock = jest.fn()
     navigateToMock = jest.fn()
 
-    // Initialize RouteService
+    // Initialize RouteService (no setCookie - plugin handles cookies)
     routeService = new RouteService(
       mockI18nConfig,
       mockRouter,
       null,
       null,
       navigateToMock,
-      setCookieMock,
-      null,
-      null,
     )
   })
 
@@ -71,14 +65,14 @@ describe('RouteService', () => {
 
   test('getCurrentLocale should return the hash locale if hashMode is enabled', () => {
     const mockI18nConfigWithHashMode = { ...mockI18nConfig, hashMode: true }
-    routeService = new RouteService(mockI18nConfigWithHashMode, mockRouter, 'de', null, navigateToMock, setCookieMock, null, null)
+    routeService = new RouteService(mockI18nConfigWithHashMode, mockRouter, 'de', null, navigateToMock)
     const locale = routeService.getCurrentLocale()
     expect(locale).toBe('de')
   })
 
   test('getCurrentLocale should return the noPrefix locale if noPrefix strategy is enabled', () => {
     const mockI18nConfigWithNoPrefix: ModuleOptionsExtend = { ...mockI18nConfig, strategy: 'no_prefix' }
-    routeService = new RouteService(mockI18nConfigWithNoPrefix, mockRouter, null, 'ru', navigateToMock, setCookieMock, null, null)
+    routeService = new RouteService(mockI18nConfigWithNoPrefix, mockRouter, null, 'ru', navigateToMock)
     const locale = routeService.getCurrentLocale()
     expect(locale).toBe('ru')
   })
@@ -92,7 +86,7 @@ describe('RouteService', () => {
         { code: 'ru', iso: 'ru-RU', displayName: 'Russian' },
       ],
     }
-    routeService = new RouteService(mockI18nConfigWithDisplayName, mockRouter, null, null, navigateToMock, setCookieMock, null, null)
+    routeService = new RouteService(mockI18nConfigWithDisplayName, mockRouter, null, null, navigateToMock)
     const route = { name: 'localized-about-en' } as RouteLocationNormalizedLoaded
     const displayName = routeService.getCurrentName(route)
     expect(displayName).toBe('English')
@@ -157,25 +151,6 @@ describe('RouteService', () => {
     expect(fullPath).toBe('https://example.com/de/about')
   })
 
-  test('updateCookies should update cookies for hashMode and noPrefixStrategy', () => {
-    const mockI18nConfigWithHashMode: ModuleOptionsExtend = {
-      ...mockI18nConfig,
-      hashMode: true,
-      strategy: 'prefix_except_default',
-    }
-    routeService = new RouteService(mockI18nConfigWithHashMode, mockRouter, 'de', null, navigateToMock, setCookieMock, null, null)
-    routeService.updateCookies('de')
-    expect(setCookieMock).toHaveBeenCalledWith('hash-locale', 'de')
-
-    const mockI18nConfigWithNoPrefix: ModuleOptionsExtend = {
-      ...mockI18nConfig,
-      strategy: 'no_prefix',
-    }
-    routeService = new RouteService(mockI18nConfigWithNoPrefix, mockRouter, null, 'ru', navigateToMock, setCookieMock, null, null)
-    routeService.updateCookies('ru')
-    expect(setCookieMock).toHaveBeenCalledWith('no-prefix-locale', 'ru')
-  })
-
   test('resolveLocalizedRoute should return the correct localized route', () => {
     const to = { path: '/about' } as RouteLocationAsPathGeneric
     mockRouter.resolve.mockReturnValueOnce({
@@ -209,21 +184,38 @@ describe('RouteService', () => {
     expect(locale).toBe('ru') // Should extract from URL
   })
 
-  test('getCurrentLocale should use cookie locale when route params and URL path are missing', () => {
+  test('getCurrentLocale should return defaultLocale for prefix_except_default when URL has no locale prefix', () => {
     routeService = new RouteService(
-      mockI18nConfig,
+      mockI18nConfig, // strategy: prefix_except_default
       mockRouter,
       null,
       null,
       navigateToMock,
-      setCookieMock,
-      'de', // cookie locale
-      'user-locale', // cookie name
+      () => 'de', // getter from plugin (cookie/state)
     )
     mockRouter.currentRoute.value.params = {} // Remove locale from params
     mockRouter.currentRoute.value.path = '/' // No locale in path
     const locale = routeService.getCurrentLocale()
-    expect(locale).toBe('de') // Should use cookie
+    // For prefix_except_default: URL without locale = defaultLocale (SEO requirement)
+    // Getter is NOT used because URL explicitly indicates defaultLocale
+    expect(locale).toBe('en')
+  })
+
+  test('getCurrentLocale should use getDefaultLocale for no_prefix strategy', () => {
+    const noPrefixConfig = { ...mockI18nConfig, strategy: 'no_prefix' as const }
+    routeService = new RouteService(
+      noPrefixConfig,
+      mockRouter,
+      null,
+      'de', // noPrefixDefault
+      navigateToMock,
+      () => 'de', // getter from plugin (cookie/state)
+    )
+    mockRouter.currentRoute.value.params = {} // Remove locale from params
+    mockRouter.currentRoute.value.path = '/' // No locale in path
+    const locale = routeService.getCurrentLocale()
+    // For no_prefix: getter/noPrefixDefault determines locale
+    expect(locale).toBe('de')
   })
 
   test('getCurrentLocale should prioritize route params over URL path', () => {
@@ -233,36 +225,19 @@ describe('RouteService', () => {
     expect(locale).toBe('de') // Should use route params
   })
 
-  test('getCurrentLocale should prioritize URL path over cookie', () => {
+  test('getCurrentLocale should prioritize URL path over getDefaultLocale', () => {
     routeService = new RouteService(
       mockI18nConfig,
       mockRouter,
       null,
       null,
       navigateToMock,
-      setCookieMock,
-      'de', // cookie locale
-      'user-locale', // cookie name
+      () => 'de', // getter
     )
     mockRouter.currentRoute.value.params = {} // No locale in params
     mockRouter.currentRoute.value.path = '/ru/sdfsdf' // URL has locale
     const locale = routeService.getCurrentLocale()
-    expect(locale).toBe('ru') // Should use URL path, not cookie
-  })
-
-  test('updateCookies should update cookie for regular strategy', () => {
-    routeService = new RouteService(
-      mockI18nConfig,
-      mockRouter,
-      null,
-      null,
-      navigateToMock,
-      setCookieMock,
-      null,
-      'user-locale', // cookie name
-    )
-    routeService.updateCookies('ru')
-    expect(setCookieMock).toHaveBeenCalledWith('user-locale', 'ru')
+    expect(locale).toBe('ru') // Should use URL path, not getter
   })
 
   test('getCurrentName should return null if displayName is missing', () => {
@@ -274,7 +249,7 @@ describe('RouteService', () => {
         { code: 'ru', iso: 'ru-RU' },
       ],
     }
-    routeService = new RouteService(mockI18nConfigWithoutDisplayName, mockRouter, null, null, navigateToMock, setCookieMock, null, null)
+    routeService = new RouteService(mockI18nConfigWithoutDisplayName, mockRouter, null, null, navigateToMock)
     const route = { name: 'localized-about-en' } as RouteLocationNormalizedLoaded
     const displayName = routeService.getCurrentName(route)
     expect(displayName).toBeNull()
@@ -350,11 +325,6 @@ describe('RouteService', () => {
     })
   })
 
-  test('updateCookies should not update cookies if hashMode and noPrefixStrategy are disabled', () => {
-    routeService.updateCookies('de')
-    expect(setCookieMock).not.toHaveBeenCalled()
-  })
-
   test('getCurrentLocale should extract locale from fullPath with query params when route.path is missing', () => {
     mockRouter.currentRoute.value.params = {}
     mockRouter.currentRoute.value.path = '' // Simulate missing path (e.g. error state)