К содержимому
← Вернуться в блог

Состояние и тестирование компонентов в приложении на Vue: как выстроить структуру

Состояние во Vue-приложении ломается редко из-за нехватки инструментов. Чаще причина в другом: часть данных живёт в компоненте, часть — в глобальном сторе, часть — в кеше запросов, и через полгода никто не помнит, где что менять. Тесты в такой ситуации либо не пишут вовсе, либо пишут так, что они падают от любого изменения разметки. Ниже — практический порядок действий: как организовать состояние и тестирование компонентов в приложении на Vue, чтобы структура оставалась понятной, а тесты помогали менять код, а не мешали.

Речь пойдёт о Vue 3 с Composition API и Pinia. Для Vue 2 общие принципы те же, но часть API отличается, поэтому сверяйтесь с документацией той версии, которая используется в проекте.

Разделите состояние по уровням, прежде чем выбирать библиотеку

Начните с инвентаризации: выпишите, какие данные вообще есть в приложении, и отнесите каждую группу к одному из четырёх уровней.

  • Локальное состояние компонента — то, что не нужно никому снаружи: открыт ли выпадающий список, какой таб активен, что введено в поле до отправки.
  • Разделяемое состояние — данные, которые читают или меняют несколько несвязанных компонентов: текущий пользователь, содержимое корзины, выбранные фильтры, тема оформления.
  • Серверные данные — то, что приходит из API и имеет срок жизни: списки, карточки, результаты поиска.
  • Состояние в URL — маршрут, query-параметры, хеш. Это тоже состояние, и часто самое полезное.

Четвёртый уровень игнорируют чаще всего, а он экономит больше кода, чем кажется. Фильтры, номер страницы пагинации, активный таб — если они лежат в query-параметрах, ссылку можно переслать, кнопка «назад» работает ожидаемо, а состояние переживает перезагрузку. Когда тот же фильтр хранится только в сторе, воспроизвести экран у коллеги получится лишь по памяти.

Дальше действует простое правило: держите данные максимально близко к месту использования и поднимайте выше только тогда, когда появился второй независимый потребитель. Преждевременный глобальный стор — та же проблема, что преждевременная оптимизация: появляется слой, через который приходится прокидывать всё подряд, а связность растёт.

Отдельно про серверные данные. Не стоит держать одну и ту же сущность и в кеше запросов, и в сторе «на всякий случай»: у данных должен быть один владелец. Если выбрали стор — запросы идут через его actions. Если библиотеку кеширования — стор не дублирует её состояние.

И ещё одна развилка, которую стоит закрыть сразу: черновик формы — это состояние компонента или приложения? Пока форма живёт на одной странице, хватит локального ref. Как только черновик нужно сохранять при переходе между шагами мастера, он переезжает на уровень выше — но не раньше.

Границы стора: что отдать Pinia, а что оставить composable

Pinia в Vue 3 — привычный инструмент для разделяемого состояния. Вопрос обычно не в том, брать её или нет, а в том, где заканчивается её зона ответственности.

Когда достаточно composable

Composable — функция, которая инкапсулирует логику и возвращает refs, computed и методы. Для состояния, нужного одной ветке компонентов, этого хватает: пагинация таблицы, черновик полей, отслеживание медиазапроса, локальная валидация. Плюс в том, что такой код тестируется без монтирования всего приложения и не тянет за собой глобальную регистрацию.

Если нужен общий экземпляр без Pinia, иногда объявляют ref на уровне модуля — все импортёры получат одно и то же состояние. Приём рабочий, но у него есть цена: при серверном рендеринге такое состояние живёт дольше одного запроса и может протечь между пользователями, а в тестах оно сохраняется между кейсами, если его не сбрасывать вручную. Если проект рендерится на сервере, безопаснее сразу взять стор.

Практический критерий переезда на Pinia: состояние переживает переход между маршрутами, у него несколько независимых потребителей, или к нему нужны devtools и предсказуемая точка входа для отладки.

Производные данные: считать, а не хранить

В сторе есть state, getters и actions, в Composition API — ref и computed. Общее правило одно: если значение выводится из другого состояния, это computed или getter, а не отдельное поле.

Представим ситуацию: в сторе лежат список позиций и итоговая сумма. Если сумма хранится отдельным полем, её придётся пересчитывать в каждом action — при добавлении, удалении, изменении количества, при загрузке сохранённого состояния. Рано или поздно один путь забудут, и интерфейс покажет неверную цифру. Computed убирает этот класс ошибок целиком.

То же с флагами: isEmpty, hasSelection, canSubmit почти всегда вычисляются, а не хранятся. Исключение — дорогие вычисления, но и тогда стоит начинать с computed и оптимизировать только при доказанной проблеме производительности.

Геттеры и computed держите чистыми: без запросов, без записи в другие поля, без обращения к текущему времени и случайным числам. Иначе они превращаются в скрытые сайд-эффекты, которые сложно тестировать и ещё сложнее отлаживать.

Имя стора и набор полей должны читаться как предметная область. Стор с названием вроде useAppStore и полями data, loading, temp — признак того, что границы ещё не найдены. Стор корзины с items, promoCode и actions addItem, removeItem понятен без комментариев.

Асинхронное состояние: статусы, гонки и нормализация

Асинхронность — место, где организация состояния проверяется на прочность. Один булев флаг isLoading редко описывает реальность: нужно отличать «ещё не начинали», «загружаем», «успех с пустым результатом» и «ошибка». Без этого пустой список и упавший запрос выглядят в интерфейсе одинаково.

Рабочая схема — хранить три вещи: данные, статус и ошибку. Статус лучше делать перечислением, а не набором флагов: idle, loading, success, error. Тогда компонент разбирает один случай, а не собирает условие из трёх булевых значений, которое легко сломать при добавлении четвёртого.

Гонки — вторая типичная проблема. Если пользователь меняет фильтр быстрее, чем приходит ответ, устаревший ответ может перезаписать свежие данные. Меры простые: отменять предыдущий запрос (в fetch для этого есть AbortController), либо помечать каждый запрос идентификатором и игнорировать ответы с неактуальным идентификатором, либо блокировать новый запрос до завершения предыдущего — но последнее ухудшает отзывчивость интерфейса.

Если состояние должно сбрасываться при выходе со страницы, заведите action reset, возвращающий стор к начальному виду, и вызывайте его осознанно: при выходе из аккаунта, при смене контекста. Тест на сброс дешёвый, а забытый сброс приводит к тому, что данные одного экрана просачиваются в другой.

Нормализация помогает, когда сущности повторяются. Вместо вложенных объектов храните записи по id и отдельный массив идентификаторов. Обновление одной записи перестаёт требовать обхода дерева, а компоненты получают данные по id и не зависят от формы вложенности. Для небольших приложений это избыточно — применяйте, когда дублирование уже реально мешает.

Про кеширование: если задач становится много — повторные запросы, инвалидация, обновление при возврате фокуса, — имеет смысл посмотреть на готовые библиотеки для серверного состояния, например TanStack Query для Vue. Они снимают часть рутины, но добавляют зависимость и собственный жизненный цикл. Перед выбором сверьтесь с актуальной документацией: API подобных инструментов заметно меняется между мажорными версиями.

Тестовая стратегия: приоритеты и разумные границы

Тесты нужны не для отчёта, а чтобы можно было менять код без страха. Отсюда приоритет: сначала то, что ломается часто и стоит дорого, потом всё остальное.

  1. Чистая логика — утилиты, нормализация, вычисления, парсинг. Тестируется быстро, без DOM и без монтирования.
  2. Сторы и composables — переходы состояний, обработка ошибок, гонки, сброс.
  3. Компоненты — контракт: какие props принимает, какие события отдаёт, как реагирует на ввод и нажатия.
  4. Интеграционные сценарии — форма целиком, страница вместе с роутером и стором.
  5. E2E — только ключевые пользовательские пути; они дорогие, медленные и хрупкие.

Такое распределение близко к идее пирамиды тестов. Важна не сама схема, а принцип: каждый следующий уровень добавляет то, чего не проверяет предыдущий. Юнит-тест не увидит, что компонент не отрисовал данные из стора, а компонентный тест не проверит, что произойдёт при отмене запроса.

Отдельно проговорите требование воспроизводимости: тест обязан падать при дефекте и проходить после исправления, независимо от порядка запуска и от машины. Тот же принцип разбора воспроизводимости подробно разобран в материале о тестировании игровых дефектов, и в вебе он работает так же: нестабильный тест хуже отсутствующего, потому что ему перестают верить и перестают читать его падения.

Осторожно с чрезмерным мокингом. Если замокать стор, HTTP-клиент, роутер и все дочерние компоненты, тест начнёт проверять моки, а не ваш код: он останется зелёным даже при полностью сломанной логике. Оставляйте настоящим то, что дёшево и важно (обычно — сам компонент и стор), а подменяйте только внешние границы: сеть, время, случайность. И помните, что тесты, привязанные к CSS-классам, порядку элементов и внутренним ref, ломаются при любом рефакторинге, не обнаруживая при этом реальных дефектов.

Ещё одна граница — что считать единицей проверки. Если тест компонента утверждает, что конкретный дочерний компонент получил конкретный prop, он фиксирует структуру, а не поведение. Проверять стоит то, что видит пользователь и что является контрактом: отправленное событие, появившийся текст, заблокированная кнопка.

Стор и composables: тесты без монтирования всего приложения

Сторы тестируются быстро, если не тянуть в тест весь интерфейс. Основной инструмент — создание свежего экземпляра Pinia на каждый тест.

Перед каждым тестом вызывайте setActivePinia(createPinia()). Без этого сторы делят состояние между кейсами, и результат начинает зависеть от порядка запуска — классический источник «мигающих» тестов, которые падают только в общем прогоне.

Если нужно проверить только state и getters, а actions заменить заглушками, пригодится createTestingPinia из пакета @pinia/testing: он подменяет actions и позволяет задать начальное состояние. Для тестов, где важна реальная логика действий, наоборот, оставляйте настоящий стор и мокайте только сетевой слой.

Помните про storeToRefs при деструктуризации стора: обычное деструктурирование забирает значение и теряет реактивность. В тестах это проявляется как «данные обновились, а computed — нет».

Composable удобно тестировать через временный компонент: он нужен только для того, чтобы у функции был контекст жизненного цикла.

import { mount } from '@vue/test-utils'

function withSetup(composable) {
  let result
  const wrapper = mount({
    setup() {
      result = composable()
      return () => null
    },
  })
  return { result, wrapper }
}

Дальше проверяйте переходы: начальное состояние, успешная загрузка, ошибка, повторный вызов, сброс. Для асинхронных сценариев используйте await flushPromises() из Vue Test Utils — он дожидается завершения очереди промисов. Для дебаунса и таймеров — vi.useFakeTimers() и vi.advanceTimersByTime(), иначе тест будет спать в реальном времени и замедлять сборку.

Отдельный кейс — гонки. Смоделируйте два запроса, где первый завершается позже второго, и убедитесь, что в состоянии остались данные второго. Такой тест пишется один раз, а защищает от регрессии надолго.

И про ошибки сети: проверьте, что стор не остаётся в состоянии загрузки навсегда, что текст ошибки сохраняется, что повторный запрос очищает предыдущую ошибку. Эти три проверки закрывают большинство проблем, которые иначе ищут в браузере вручную.

Тестирование компонентов на Vue: проверяйте контракт, а не внутренности

Контракт компонента — это props, события, слоты и то, что пользователь видит и может сделать. Всё остальное относится к внутренней реализации, и тесты не должны за неё цепляться.

В Vue Test Utils для Vue 3 монтирование выполняется через mount. Опция shallow: true заменяет дочерние компоненты заглушками — это удобно, когда тестируется один компонент, а окружение сложное. Для точечной подмены используйте global.stubs: такой вариант явнее, чем глобальный shallow, потому что сразу видно, что именно заменено.

Ищите элементы так, как их находит пользователь: по роли, подписи, тексту. В Vue Test Utils для этого есть find и get с селекторами, а библиотека @testing-library/vue предлагает запросы по доступному имени и роли. Побочный эффект приятный: если элемент не находится по роли, скорее всего, у него проблемы с доступностью.

События проверяются через wrapper.emitted(). После клика по кнопке ожидаем, что компонент отдал событие submit с нужным payload, а не что у кнопки появился класс active. Первое переживёт рефакторинг стилей, второе — нет.

Роутер в тестах поднимайте настоящий, но с createMemoryHistory: тогда переходы работают без реального адреса, а компоненты, зависящие от маршрута, не требуют моков. Аналогично со стором: реальная Pinia часто дешевле, чем аккуратно собранный набор заглушек.

Снапшоты полезны точечно — для маленьких презентационных компонентов, где важно увидеть diff разметки. Снапшот целой страницы почти всегда превращается в формальность: его обновляют не глядя, и он перестаёт что-либо гарантировать.

Если в проекте есть собственные правила оформления компонентов — например, гайдлайн по графическим компонентам, — их стоит превратить в проверяемые договорённости: одинаковые имена props, единый формат событий, предсказуемые слоты. Тогда компонентные тесты становятся ещё и защитой от расхождений между командами.

И последнее: не гонитесь за процентом покрытия. Покрытие показывает, какой код выполнился, но не говорит, проверены ли важные сценарии. Практичнее держать список критичных путей — вход в аккаунт, оформление заказа, сохранение формы — и следить, чтобы они были покрыты. Когда это выполнено, рефакторинг перестаёт быть страшным, а структура состояния и тестов поддерживает друг друга, а не конфликтует.

Обязательно ли использовать Pinia в приложении на Vue?

Нет. Для локального состояния хватает ref и computed внутри компонента, для повторяемой логики — composable. Pinia нужна там, где состояние разделяется между удалёнными ветками компонентов, переживает переходы между страницами или требует удобной отладки. Если такого состояния в проекте мало, глобальный стор может оказаться лишним слоем.

Чем Pinia отличается от Vuex и что выбрать для нового проекта?

Документация Vue 3 ориентирует на Pinia: у неё более простой API и хорошая поддержка TypeScript. Vuex остаётся рабочим вариантом, и в существующих проектах его часто нет смысла переписывать. Для нового кода обычно берут Pinia, но конкретную версию и совместимость с остальными зависимостями стоит проверить в актуальной документации.

Как тестировать компонент, который использует Pinia?

Есть два подхода. Первый — настоящий стор: перед каждым тестом создавайте новый экземпляр через setActivePinia(createPinia()) и наполняйте его нужным состоянием. Второй — createTestingPinia из @pinia/testing, который подменяет actions заглушками и позволяет задать начальное состояние. Первый точнее проверяет логику, второй быстрее и изолированнее.

Что делать с асинхронными запросами в тестах?

Мокайте сетевой слой, а не сам компонент. Дожидайтесь завершения промисов через await flushPromises(), для таймеров и дебаунса используйте фейковые таймеры. Если запросов много, посмотрите в сторону перехвата сети на уровне сервис-воркера, например MSW. Проверьте, что тест не зависит от реальной сети и не спит в реальном времени.

Сколько тестов достаточно, чтобы считать код покрытым?

Универсального числа нет, а процент покрытия сам по себе — плохой ориентир. Практический критерий: ключевые пользовательские сценарии и переходы состояний проверены, а тесты падают при внесении дефекта в соответствующую логику. Если тест проходит и при сломанном коде, он не выполняет свою задачу.