itube-specs 0.0.707 → 0.0.712

package/composables/use-filter-scheme.test.ts

@@ -0,0 +1,57 @@
+// @vitest-environment nuxt
+import { describe, it, expect } from 'vitest';
+import { useFilterScheme } from './use-filter-scheme';
+
+const t = (key: string) => key;
+
+describe('useFilterScheme', () => {
+  it('пустой массив для null', () => {
+    const { filterScheme } = useFilterScheme(t, null);
+    expect(filterScheme.value).toEqual([]);
+  });
+
+  it('трансформирует группы в схему', () => {
+    const groups = [{
+      title: 'Age', name: 'age', icon: 'age-icon',
+      categories: [
+        { title: 'teen', name: 'teen' },
+        { title: 'milf', name: 'milf' },
+      ],
+    }];
+    const { filterScheme } = useFilterScheme(t, groups);
+    expect(filterScheme.value).toHaveLength(1);
+    expect(filterScheme.value[0].label).toBe('Age');
+    expect(filterScheme.value[0].items).toEqual([
+      { title: 'Teen', value: 'teen' },
+      { title: 'Milf', value: 'milf' },
+    ]);
+  });
+
+  it('capitalize для multi-word', () => {
+    const groups = [{
+      title: 'Body', name: 'body', icon: '',
+      categories: [{ title: 'big tits', name: 'big-tits' }],
+    }];
+    const { filterScheme } = useFilterScheme(t, groups);
+    expect(filterScheme.value[0].items[0].title).toBe('Big Tits');
+  });
+
+  it('фильтрует пустые группы', () => {
+    const groups = [
+      { title: 'Empty', name: 'empty', icon: '', categories: [] },
+      { title: 'Body', name: 'body', icon: '', categories: [{ title: 'slim', name: 'slim' }] },
+    ];
+    const { filterScheme } = useFilterScheme(t, groups);
+    expect(filterScheme.value).toHaveLength(1);
+    expect(filterScheme.value[0].name).toBe('body');
+  });
+
+  it('placeholder из t()', () => {
+    const groups = [{
+      title: 'Age', name: 'age', icon: '',
+      categories: [{ title: 'teen', name: 'teen' }],
+    }];
+    const { filterScheme } = useFilterScheme(t, groups);
+    expect(filterScheme.value[0].placeholder).toBe('choose_category');
+  });
+});

package/composables/use-get-pure-route-name.test.ts

@@ -0,0 +1,30 @@
+import { vi, describe, it, expect } from 'vitest';
+
+vi.mock('vue-router', () => ({
+  useRoute: vi.fn(),
+}));
+
+import { useRoute } from 'vue-router';
+import { useGetPureRouteName } from './use-get-pure-route-name';
+
+describe('useGetPureRouteName', () => {
+  it('убирает суффикс ___en', () => {
+    vi.mocked(useRoute).mockReturnValue({ name: 'videos___en' } as any);
+    expect(useGetPureRouteName()).toBe('videos');
+  });
+
+  it('убирает суффикс ___zh-hans', () => {
+    vi.mocked(useRoute).mockReturnValue({ name: 'user-settings___zh-hans' } as any);
+    expect(useGetPureRouteName()).toBe('user-settings');
+  });
+
+  it('оставляет имя без суффикса', () => {
+    vi.mocked(useRoute).mockReturnValue({ name: 'videos' } as any);
+    expect(useGetPureRouteName()).toBe('videos');
+  });
+
+  it('вложенный роут с суффиксом', () => {
+    vi.mocked(useRoute).mockReturnValue({ name: 'user-playlists-id___en' } as any);
+    expect(useGetPureRouteName()).toBe('user-playlists-id');
+  });
+});

package/composables/use-get-videos-filter-request.test.ts

@@ -0,0 +1,45 @@
+import { vi, describe, it, expect } from 'vitest';
+
+vi.mock('../runtime', () => ({
+  getMultipleQuery: () => ({}),
+}));
+
+import { useGetVideosFilterRequest } from './use-get-videos-filter-request';
+
+describe('useGetVideosFilterRequest', () => {
+  it('всегда возвращает categories_filter_use_and', () => {
+    const route = { query: {} } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories_filter_use_and).toBe(true);
+  });
+
+  it('парсит строковые категории', () => {
+    const route = { query: { categories: 'age_teen,body_slim' } } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories).toEqual(['teen', 'slim']);
+  });
+
+  it('парсит массив категорий', () => {
+    const route = { query: { categories: ['age_teen', 'body_slim,body_athletic'] } } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories).toEqual(['teen', 'slim', 'athletic']);
+  });
+
+  it('убирает префикс группы из категории', () => {
+    const route = { query: { categories: 'ethnicity_asian' } } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories).toEqual(['asian']);
+  });
+
+  it('сохраняет _ в значении категории', () => {
+    const route = { query: { categories: 'body_big_tits' } } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories).toEqual(['big_tits']);
+  });
+
+  it('нет categories при пустом query', () => {
+    const route = { query: {} } as any;
+    const result = useGetVideosFilterRequest(route, [], []);
+    expect(result.categories).toBeUndefined();
+  });
+});

package/composables/use-model-filter-chips.test.ts

@@ -0,0 +1,67 @@
+// @vitest-environment nuxt
+import { describe, it, expect } from 'vitest';
+import { useFilterChipsItems } from './use-model-filter-chips';
+
+const t = (key: string) => key;
+
+describe('useFilterChipsItems', () => {
+  it('пустой массив без filter_ в query', () => {
+    const filters = ref([]);
+    const route = { query: {} };
+    const { chipsItems } = useFilterChipsItems(filters, route, t);
+    expect(chipsItems.value).toEqual([]);
+  });
+
+  it('игнорирует не-filter параметры', () => {
+    const filters = ref([]);
+    const route = { query: { page: '1', sort: 'popular' } };
+    const { chipsItems } = useFilterChipsItems(filters, route, t);
+    expect(chipsItems.value).toEqual([]);
+  });
+
+  it('создаёт чип из одного фильтра', () => {
+    const filters = ref([{
+      name: 'hair_color',
+      title: 'Hair color',
+      options: [
+        { name: 'blonde', title: 'Blonde' },
+        { name: 'brunette', title: 'Brunette' },
+      ],
+    }]);
+    const route = { query: { filter_hair_color: 'blonde' } };
+    const { chipsItems } = useFilterChipsItems(filters, route, t);
+    expect(chipsItems.value).toHaveLength(1);
+    expect(chipsItems.value[0].title).toBe('Hair color: Blonde');
+    expect(chipsItems.value[0].value).toEqual(['filter_hair_color']);
+  });
+
+  it('группирует from/to фильтры', () => {
+    const filters = ref([{
+      name: 'age',
+      title: 'Age',
+      options: [
+        { name: '18', title: '18' },
+        { name: '50', title: '50' },
+      ],
+    }]);
+    const route = { query: { filter_age_from: '18', filter_age_to: '30' } };
+    const { chipsItems } = useFilterChipsItems(filters, route, t);
+    expect(chipsItems.value).toHaveLength(1);
+    expect(chipsItems.value[0].title).toBe('Age: 18 - 30');
+    expect(chipsItems.value[0].value).toEqual(['filter_age_from', 'filter_age_to']);
+  });
+
+  it('числовое значение возвращается как есть', () => {
+    const filters = ref([{
+      name: 'weight',
+      title: 'Weight',
+      options: [
+        { name: '40', title: '40' },
+        { name: '120', title: '120' },
+      ],
+    }]);
+    const route = { query: { filter_weight: '65' } };
+    const { chipsItems } = useFilterChipsItems(filters, route, t);
+    expect(chipsItems.value[0].title).toBe('Weight: 65');
+  });
+});

package/composables/use-seo-links.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment nuxt
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mockNuxtImport } from '@nuxt/test-utils/runtime';
+import { useSeoLinks } from './use-seo-links';
+
+let mockRoute = { path: '/videos', query: {} as Record<string, any> };
+
+mockNuxtImport('useRoute', () => () => mockRoute);
+
+const mockI18n = {
+  locale: { value: 'en' },
+  locales: { value: ['en', 'fr', 'de', 'ja', 'zh'] },
+};
+
+const mockLocalePath = (path: string, locale: string) =>
+  locale === 'en' ? path : `/${locale}${path}`;
+
+describe('useSeoLinks', () => {
+  beforeEach(() => {
+    mockRoute = { path: '/videos', query: {} };
+    mockI18n.locale.value = 'en';
+  });
+
+  it('canonical URL', () => {
+    const { canonicalUrl } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    expect(canonicalUrl.value).toBe('https://example.com/videos');
+  });
+
+  it('canonical с query params', () => {
+    mockRoute = { path: '/videos', query: { page: '2', sort: 'popular' } };
+    const { canonicalUrl } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    expect(canonicalUrl.value).toContain('page=2');
+    expect(canonicalUrl.value).toContain('sort=popular');
+  });
+
+  it('исключает sort при alonePage', () => {
+    mockRoute = { path: '/videos', query: { page: '2', sort: 'popular' } };
+    const { canonicalUrl } = useSeoLinks('https://example.com', true, mockI18n, mockLocalePath);
+    expect(canonicalUrl.value).toContain('page=2');
+    expect(canonicalUrl.value).not.toContain('sort');
+  });
+
+  it('alternate links для всех локалей', () => {
+    const { alternateLinks } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    const hreflangs = alternateLinks.value.map(l => l.hreflang);
+    expect(hreflangs).toContain('en');
+    expect(hreflangs).toContain('fr');
+    expect(hreflangs).toContain('de');
+    expect(hreflangs).toContain('ja-JP');
+    expect(hreflangs).toContain('zh-CN');
+    expect(hreflangs).toContain('x-default');
+  });
+
+  it('ja маппится в ja-JP', () => {
+    const { alternateLinks } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    const jaLink = alternateLinks.value.find(l => l.hreflang === 'ja-JP');
+    expect(jaLink).toBeDefined();
+    expect(jaLink!.href).toContain('/ja/videos');
+  });
+
+  it('x-default указывает на en', () => {
+    const { alternateLinks } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    const xDefault = alternateLinks.value.find(l => l.hreflang === 'x-default');
+    expect(xDefault!.href).toBe('https://example.com/videos');
+  });
+
+  it('игнорирует неразрешённые query params', () => {
+    mockRoute = { path: '/videos', query: { page: '1', foo: 'bar', categories: 'teen' } };
+    const { canonicalUrl } = useSeoLinks('https://example.com', false, mockI18n, mockLocalePath);
+    expect(canonicalUrl.value).toContain('page=1');
+    expect(canonicalUrl.value).toContain('categories=teen');
+    expect(canonicalUrl.value).not.toContain('foo');
+  });
+});

package/composables/use-slug.test.ts

@@ -0,0 +1,36 @@
+// @vitest-environment nuxt
+import { vi, describe, it, expect } from 'vitest';
+
+vi.mock('vue-router', async (importOriginal) => {
+  const mod = await importOriginal<typeof import('vue-router')>();
+  return { ...mod, useRoute: vi.fn() };
+});
+
+import { useRoute } from 'vue-router';
+import { useSlug } from './use-slug';
+
+describe('useSlug', () => {
+  it('конвертирует kebab-case slug', () => {
+    vi.mocked(useRoute).mockReturnValue({ params: { slug: 'john-doe' } } as any);
+    const slug = useSlug();
+    expect(slug.value).toBe('john doe');
+  });
+
+  it('пустая строка если slug отсутствует', () => {
+    vi.mocked(useRoute).mockReturnValue({ params: {} } as any);
+    const slug = useSlug();
+    expect(slug.value).toBe('');
+  });
+
+  it('кастомное имя параметра', () => {
+    vi.mocked(useRoute).mockReturnValue({ params: { name: 'big-tits' } } as any);
+    const slug = useSlug('name');
+    expect(slug.value).toBe('big tits');
+  });
+
+  it('slug с подчёркиваниями', () => {
+    vi.mocked(useRoute).mockReturnValue({ params: { slug: 'some_thing' } } as any);
+    const slug = useSlug();
+    expect(slug.value).toBe('some-thing');
+  });
+});

package/composables/use-snackbar.test.ts

@@ -0,0 +1,64 @@
+// @vitest-environment nuxt
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { useSnackbar } from './use-snackbar';
+
+describe('useSnackbar', () => {
+  beforeEach(() => {
+    useNuxtApp().payload.state = {};
+    vi.useFakeTimers();
+    const { resetSnackbar } = useSnackbar();
+    resetSnackbar();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('дефолтное состояние', () => {
+    const { snackbarTheme, snackbarText, snackbarIcon, snackbarTimer } = useSnackbar();
+    expect(snackbarTheme.value).toBe('success');
+    expect(snackbarText.value).toBe('');
+    expect(snackbarIcon.value).toBe('check');
+    expect(snackbarTimer.value).toBe(2000);
+  });
+
+  it('setErrorState устанавливает ошибку', () => {
+    const { setErrorState, snackbarTheme, snackbarIcon, snackbarTimer, snackbarText } = useSnackbar();
+    setErrorState({ message: 'Something failed' });
+    expect(snackbarTheme.value).toBe('error');
+    expect(snackbarIcon.value).toBe('close');
+    expect(snackbarTimer.value).toBe(4000);
+    expect(snackbarText.value).toBe('Something failed');
+  });
+
+  it('showErrorSnack показывает и авто-сбрасывает', () => {
+    const { showErrorSnack, snackbarText, snackbarTheme } = useSnackbar();
+    showErrorSnack('Error!');
+    expect(snackbarText.value).toBe('Error!');
+    expect(snackbarTheme.value).toBe('error');
+
+    vi.advanceTimersByTime(4000);
+    expect(snackbarText.value).toBe('');
+    expect(snackbarTheme.value).toBe('success');
+  });
+
+  it('повторный showErrorSnack сбрасывает предыдущий таймер', () => {
+    const { showErrorSnack, snackbarText } = useSnackbar();
+    showErrorSnack('First');
+    vi.advanceTimersByTime(2000);
+    showErrorSnack('Second');
+    expect(snackbarText.value).toBe('Second');
+
+    vi.advanceTimersByTime(4000);
+    expect(snackbarText.value).toBe('');
+  });
+
+  it('resetSnackbar сбрасывает всё', () => {
+    const { showErrorSnack, resetSnackbar, snackbarText, snackbarTheme, snackbarIcon } = useSnackbar();
+    showErrorSnack('Error');
+    resetSnackbar();
+    expect(snackbarText.value).toBe('');
+    expect(snackbarTheme.value).toBe('success');
+    expect(snackbarIcon.value).toBe('check');
+  });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "itube-specs",
   "type": "module",
-  "version": "0.0.707",
+  "version": "0.0.712",
   "main": "./nuxt.config.ts",
   "types": "./types/index.d.ts",
   "scripts": {

package/runtime/utils/converters/convert-date-to-timestamp.test.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { convertDateToTimestamp } from './convert-date-to-timestamp';
+
+const c = convertDateToTimestamp();
+
+describe('convertDateToTimestamp', () => {
+  describe('toUnix', () => {
+    it('валидная дата', () => {
+      expect(c.toUnix('2025-01-01')).toBe(Date.UTC(2025, 0, 1) / 1000);
+    });
+
+    it('начало эпохи', () => {
+      expect(c.toUnix('1970-01-01')).toBe(0);
+    });
+
+    it('невалидная дата → null', () => {
+      expect(c.toUnix('invalid')).toBe(null);
+    });
+  });
+
+  describe('fromUnix', () => {
+    it('timestamp → дата', () => {
+      expect(c.fromUnix(0)).toBe('1970-01-01');
+    });
+
+    it('конкретная дата', () => {
+      const ts = Date.UTC(2024, 2, 5) / 1000;
+      expect(c.fromUnix(ts)).toBe('2024-03-05');
+    });
+  });
+
+  describe('roundtrip', () => {
+    it('toUnix → fromUnix', () => {
+      const date = '2024-03-05';
+      expect(c.fromUnix(c.toUnix(date)!)).toBe(date);
+    });
+  });
+});

package/runtime/utils/converters/convert-snake-keys-to-camel.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { convertSnakeKeysToCamel } from './convert-snake-keys-to-camel';
+
+describe('convertSnakeKeysToCamel', () => {
+  it('простой объект', () => {
+    expect(convertSnakeKeysToCamel({ user_name: 'John', is_active: true }))
+      .toEqual({ userName: 'John', isActive: true });
+  });
+
+  it('вложенный объект', () => {
+    expect(convertSnakeKeysToCamel({ user_info: { first_name: 'John' } }))
+      .toEqual({ userInfo: { firstName: 'John' } });
+  });
+
+  it('массив объектов', () => {
+    expect(convertSnakeKeysToCamel([{ video_id: 1 }, { video_id: 2 }]))
+      .toEqual([{ videoId: 1 }, { videoId: 2 }]);
+  });
+
+  it('примитив возвращается как есть', () => {
+    expect(convertSnakeKeysToCamel('hello')).toBe('hello');
+    expect(convertSnakeKeysToCamel(42)).toBe(42);
+    expect(convertSnakeKeysToCamel(null)).toBe(null);
+  });
+
+  it('ключ без подчёркиваний', () => {
+    expect(convertSnakeKeysToCamel({ name: 'John' })).toEqual({ name: 'John' });
+  });
+});

package/runtime/utils/converters/convert-string.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import { convertString } from './convert-string';
+
+const s = convertString();
+
+describe('convertString', () => {
+  describe('toSlug', () => {
+    it('пробелы → дефисы', () => {
+      expect(s.toSlug('Big Tits')).toBe('big-tits');
+    });
+
+    it('дефисы → подчёркивания', () => {
+      expect(s.toSlug('A-B')).toBe('a_b');
+    });
+
+    it('подчёркивания → тильда', () => {
+      expect(s.toSlug('a_b')).toBe('a~b');
+    });
+  });
+
+  describe('fromSlug', () => {
+    it('дефисы → пробелы', () => {
+      expect(s.fromSlug('big-tits')).toBe('big tits');
+    });
+
+    it('подчёркивания → дефисы', () => {
+      expect(s.fromSlug('a_b')).toBe('a-b');
+    });
+
+    it('тильда → подчёркивание', () => {
+      expect(s.fromSlug('a~b')).toBe('a_b');
+    });
+  });
+
+  describe('toSnakeCase', () => {
+    it('camelCase', () => {
+      expect(s.toSnakeCase('bigTits')).toBe('big_tits');
+    });
+
+    it('пробелы', () => {
+      expect(s.toSnakeCase('big tits')).toBe('big_tits');
+    });
+
+    it('дефисы', () => {
+      expect(s.toSnakeCase('big-tits')).toBe('big_tits');
+    });
+  });
+
+  describe('toKebabCase', () => {
+    it('camelCase', () => {
+      expect(s.toKebabCase('bigTits')).toBe('big-tits');
+    });
+
+    it('подчёркивания', () => {
+      expect(s.toKebabCase('big_tits')).toBe('big-tits');
+    });
+
+    it('пробелы', () => {
+      expect(s.toKebabCase('big tits')).toBe('big-tits');
+    });
+  });
+
+  describe('toCapitalize', () => {
+    it('одно слово', () => {
+      expect(s.toCapitalize('teen')).toBe('Teen');
+    });
+
+    it('несколько слов', () => {
+      expect(s.toCapitalize('big tits')).toBe('Big Tits');
+    });
+  });
+
+  describe('roundtrip', () => {
+    it('toSlug → fromSlug', () => {
+      expect(s.fromSlug(s.toSlug('Big Tits'))).toBe('big tits');
+    });
+  });
+});

package/runtime/utils/converters/group-objects-by-first-letter.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { groupObjectsByFirstLetter } from './group-objects-by-first-letter';
+
+describe('groupObjectsByFirstLetter', () => {
+  const items = [
+    { name: 'Alice' },
+    { name: 'Anna' },
+    { name: 'Bob' },
+    { name: '123test' },
+  ];
+
+  it('группирует по первой букве', () => {
+    const result = groupObjectsByFirstLetter(items, 'name');
+    expect(result['A']).toHaveLength(2);
+    expect(result['B']).toHaveLength(1);
+  });
+
+  it('цифры попадают в POST', () => {
+    const result = groupObjectsByFirstLetter(items, 'name');
+    expect(result['POST']).toHaveLength(1);
+    expect(result['POST'][0]).toEqual({ name: '123test' });
+  });
+
+  it('кастомный nonLetterKey', () => {
+    const result = groupObjectsByFirstLetter(items, 'name', 'OTHER');
+    expect(result['OTHER']).toHaveLength(1);
+  });
+
+  it('пустой массив', () => {
+    const result = groupObjectsByFirstLetter([], 'name');
+    expect(result).toEqual({});
+  });
+});

package/runtime/utils/format-date.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { formatDate } from './format-date';
+
+describe('formatDate', () => {
+  it('обычная дата', () => {
+    // 2025-01-15 00:00:00 UTC
+    expect(formatDate(1736899200)).toBe('15.01.2025');
+  });
+
+  it('начало эпохи', () => {
+    expect(formatDate(0)).toBe('01.01.1970');
+  });
+
+  it('с padding нулей', () => {
+    // 2024-03-05 UTC
+    expect(formatDate(1709596800)).toBe('05.03.2024');
+  });
+});

package/runtime/utils/format-number.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { formatNumber } from './format-number';
+
+describe('formatNumber', () => {
+  it('тысячи', () => {
+    expect(formatNumber(10400)).toBe('10.4K');
+  });
+
+  it('миллионы', () => {
+    expect(formatNumber(1500000)).toBe('1.5M');
+  });
+
+  it('маленькое число без сокращения', () => {
+    expect(formatNumber(999)).toBe('999');
+  });
+
+  it('ноль', () => {
+    expect(formatNumber(0)).toBe('0');
+  });
+
+  it('ровно тысяча', () => {
+    expect(formatNumber(1000)).toBe('1K');
+  });
+});

package/runtime/utils/format-time-ago.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { formatTimeAgo } from './format-time-ago';
+
+const t = (key: string) => key;
+
+describe('formatTimeAgo', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-06-15T12:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  const now = () => Math.floor(Date.now() / 1000);
+
+  it('сегодня', () => {
+    expect(formatTimeAgo(now(), t)).toBe('today');
+  });
+
+  it('1 день назад', () => {
+    expect(formatTimeAgo(now() - 86400, t)).toBe('day_ago');
+  });
+
+  it('5 дней назад', () => {
+    expect(formatTimeAgo(now() - 5 * 86400, t)).toBe('5 days_ago');
+  });
+
+  it('29 дней назад', () => {
+    expect(formatTimeAgo(now() - 29 * 86400, t)).toBe('29 days_ago');
+  });
+
+  it('1 месяц', () => {
+    expect(formatTimeAgo(now() - 31 * 86400, t)).toBe('1 month ago');
+  });
+
+  it('3 месяца — plural', () => {
+    expect(formatTimeAgo(now() - 90 * 86400, t)).toBe('3 months ago');
+  });
+
+  it('1 год', () => {
+    expect(formatTimeAgo(now() - 366 * 86400, t)).toBe('1 year ago');
+  });
+
+  it('2 года — plural', () => {
+    expect(formatTimeAgo(now() - 730 * 86400, t)).toBe('2 years ago');
+  });
+});

package/runtime/utils/format-time.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { formatTime } from './format-time';
+
+describe('formatTime', () => {
+  it('только секунды', () => {
+    expect(formatTime(5)).toBe('00:05');
+  });
+
+  it('минуты и секунды', () => {
+    expect(formatTime(65)).toBe('01:05');
+  });
+
+  it('часы, минуты, секунды', () => {
+    expect(formatTime(3661)).toBe('01:01:01');
+  });
+
+  it('ноль', () => {
+    expect(formatTime(0)).toBe('00:00');
+  });
+
+  it('ровно час', () => {
+    expect(formatTime(3600)).toBe('01:00:00');
+  });
+});

package/runtime/utils/get-duration.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { getDuration } from './get-duration';
+
+describe('getDuration', () => {
+  it('только секунды', () => {
+    expect(getDuration(45)).toBe('00:45');
+  });
+
+  it('минуты и секунды', () => {
+    expect(getDuration(125)).toBe('02:05');
+  });
+
+  it('с часами', () => {
+    expect(getDuration(3661)).toBe('01:01:01');
+  });
+
+  it('ноль', () => {
+    expect(getDuration(0)).toBe('00:00');
+  });
+
+  it('ровно час', () => {
+    expect(getDuration(3600)).toBe('01:00:00');
+  });
+});

package/runtime/utils/get-month.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { getMonth } from './get-month';
+
+const t = (key: string) => key;
+
+describe('getMonth', () => {
+  it('январь = 0', () => {
+    expect(getMonth(t, 0)).toBe('january');
+  });
+
+  it('декабрь = 11', () => {
+    expect(getMonth(t, 11)).toBe('december');
+  });
+
+  it('июнь = 5', () => {
+    expect(getMonth(t, 5)).toBe('june');
+  });
+
+  it('undefined → декабрь (дефолт)', () => {
+    expect(getMonth(t)).toBe('december');
+  });
+
+  it('отрицательное число → декабрь', () => {
+    expect(getMonth(t, -1)).toBe('december');
+  });
+
+  it('число >= 12 → декабрь', () => {
+    expect(getMonth(t, 12)).toBe('december');
+  });
+});

package/runtime/utils/normalize-url.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { normalizeUrl } from './normalize-url';
+
+describe('normalizeUrl', () => {
+  it('удаляет page=1', () => {
+    const result = normalizeUrl({ path: '/videos', query: { page: '1' } });
+    expect(result.query.page).toBeUndefined();
+  });
+
+  it('сохраняет page=2', () => {
+    const result = normalizeUrl({ path: '/videos', query: { page: '2' } });
+    expect(result.query.page).toBe('2');
+  });
+
+  it('удаляет sort=trending', () => {
+    const result = normalizeUrl({ path: '/videos', query: { sort: 'trending' } });
+    expect(result.query.sort).toBeUndefined();
+  });
+
+  it('сохраняет sort=popular', () => {
+    const result = normalizeUrl({ path: '/videos', query: { sort: 'popular' } });
+    expect(result.query.sort).toBe('popular');
+  });
+
+  it('удаляет пустые значения', () => {
+    const result = normalizeUrl({ path: '/', query: { a: '', b: null as any, c: 'ok' } });
+    expect(result.query).toEqual({ c: 'ok' });
+  });
+
+  it('lowercase путь', () => {
+    const result = normalizeUrl({ path: '/Videos/BIG', query: {} });
+    expect(result.path).toBe('/videos/big');
+  });
+
+  it('lowercase query', () => {
+    const result = normalizeUrl({ path: '/', query: { Sort: 'Popular' } });
+    expect(result.query).toEqual({ sort: 'popular' });
+  });
+
+  it('%20 и пробелы → дефисы', () => {
+    const result = normalizeUrl({ path: '/big%20tits videos', query: {} });
+    expect(result.path).toBe('/big-tits-videos');
+  });
+
+  it('убирает двойные дефисы', () => {
+    const result = normalizeUrl({ path: '/big--tits', query: {} });
+    expect(result.path).toBe('/big-tits');
+  });
+
+  it('убирает trailing slash', () => {
+    const result = normalizeUrl({ path: '/videos/', query: {} });
+    expect(result.path).toBe('/videos');
+  });
+
+  it('не убирает /', () => {
+    const result = normalizeUrl({ path: '/', query: {} });
+    expect(result.path).toBe('/');
+  });
+});

package/runtime/utils/server/parse-api-error.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { parseApiError } from './parse-api-error';
+
+describe('parseApiError', () => {
+  it('error.message', () => {
+    expect(parseApiError({ message: 'Not found' })).toBe('Not found');
+  });
+
+  it('response._data как объект', () => {
+    const error = { response: { _data: { error: 'Bad request' } } };
+    expect(parseApiError(error)).toBe('Bad request');
+  });
+
+  it('response._data как JSON строка', () => {
+    const error = { response: { _data: '{"error":"Forbidden"}' } };
+    expect(parseApiError(error)).toBe('Forbidden');
+  });
+
+  it('вложенный data.error', () => {
+    const error = { response: { _data: { data: { error: 'Validation failed' } } } };
+    expect(parseApiError(error)).toBe('Validation failed');
+  });
+
+  it('массив ошибок — первый элемент', () => {
+    const error = { response: { _data: { error: ['Field required', 'Too short'] } } };
+    expect(parseApiError(error)).toBe('Field required');
+  });
+
+  it('fallback при null', () => {
+    expect(parseApiError(null)).toBe('Unknown error occurred.');
+  });
+
+  it('fallback при пустом объекте', () => {
+    expect(parseApiError({})).toBe('Unknown error occurred.');
+  });
+});

package/runtime/utils/validate-email.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { validateEmail } from './validate-email';
+
+describe('validateEmail', () => {
+  it('валидный email', () => {
+    expect(validateEmail('user@example.com')).toBe(true);
+  });
+
+  it('с точкой в имени', () => {
+    expect(validateEmail('first.last@example.com')).toBe(true);
+  });
+
+  it('с поддоменом', () => {
+    expect(validateEmail('user@mail.example.com')).toBe(true);
+  });
+
+  it('без @', () => {
+    expect(validateEmail('userexample.com')).toBe(false);
+  });
+
+  it('без домена', () => {
+    expect(validateEmail('user@')).toBe(false);
+  });
+
+  it('пустая строка', () => {
+    expect(validateEmail('')).toBe(false);
+  });
+
+  it('пробелы', () => {
+    expect(validateEmail('user @example.com')).toBe(false);
+  });
+});

package/runtime/utils/validate-password.test.ts

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { validatePassword } from './validate-password';
+
+describe('validatePassword', () => {
+  it('длина > 4 — валиден', () => {
+    expect(validatePassword('12345')).toBe(true);
+  });
+
+  it('длина 4 — невалиден', () => {
+    expect(validatePassword('1234')).toBe(false);
+  });
+
+  it('длина 1 — невалиден', () => {
+    expect(validatePassword('a')).toBe(false);
+  });
+
+  it('длинный пароль', () => {
+    expect(validatePassword('super_secure_password_123')).toBe(true);
+  });
+});

package/runtime/utils/validate-phone.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { validatePhone } from './validate-phone';
+
+describe('validatePhone', () => {
+  it('международный формат', () => {
+    expect(validatePhone('+79001234567')).toBe(true);
+  });
+
+  it('с дефисами', () => {
+    expect(validatePhone('8-900-123-45-67')).toBe(true);
+  });
+
+  it('с пробелами', () => {
+    expect(validatePhone('+7 900 123 4567')).toBe(true);
+  });
+
+  it('со скобками', () => {
+    expect(validatePhone('+7(900)1234567')).toBe(true);
+  });
+
+  it('слишком короткий', () => {
+    expect(validatePhone('12345')).toBe(false);
+  });
+
+  it('пустая строка', () => {
+    expect(validatePhone('')).toBe(false);
+  });
+
+  it('буквы', () => {
+    expect(validatePhone('phone123')).toBe(false);
+  });
+});

package/runtime/utils/validate-username.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { validateUsername } from './validate-username';
+
+describe('validateUsername', () => {
+  it('латиница', () => {
+    expect(validateUsername('john')).toBe(true);
+  });
+
+  it('с цифрами', () => {
+    expect(validateUsername('user123')).toBe(true);
+  });
+
+  it('с подчёркиванием и дефисом', () => {
+    expect(validateUsername('my_user-name')).toBe(true);
+  });
+
+  it('1 символ — невалиден', () => {
+    expect(validateUsername('a')).toBe(false);
+  });
+
+  it('21 символ — невалиден', () => {
+    expect(validateUsername('a'.repeat(21))).toBe(false);
+  });
+
+  it('20 символов — валиден', () => {
+    expect(validateUsername('a'.repeat(20))).toBe(true);
+  });
+
+  it('пустая строка', () => {
+    expect(validateUsername('')).toBe(false);
+  });
+
+  it('спецсимволы', () => {
+    expect(validateUsername('user@name')).toBe(false);
+  });
+});