Kurs Vue.js · Moduł 12: Testy i wdrożenie

Testing Vue Components

6 min czytania ·
W tej lekcji9

Witaj na Platformie Startowej NOVA LAB! Rok 2087 - przed wysłaniem systemów na Marsa, każdy kod musi przejść rygorystyczne testy. Podobnie jak systemy rakietowe są sprawdzane przed startem, tak testujemy nasze aplikacje Vue przed wdrożeniem.

Panel telemetrii sprawdziłeś ręcznie: każdy przycisk działa. Za tydzień ktoś z zespołu poprawi jeden komponent, a przycisk "+" przestanie działać w miejscu, którego nikt już nie kliknie. Ręczne sprawdzanie się nie skaluje. Test automatyczny to procedura przedstartowa zapisana w kodzie - uruchamiasz ją jednym poleceniem przed każdym startem.

Czego się nauczysz

Na Platformie Startowej przygotujesz aplikację do lotu:

  • pisać testy komponentów z Vitest i Vue Test Utils,
  • testować composables i store Pinia bez montowania interfejsu,
  • sprawdzać współpracę modułów w testach integracyjnych i E2E,
  • budować wersję produkcyjną i wdrażać ją na hosting,
  • automatyzować cały proces w pipeline CI/CD.

Po co testy i jakie mają rodzaje

Testy zapewniają jakość kodu, wykrywają błędy wcześnie i ułatwiają refactoring: zmieniasz wnętrze komponentu, a zielone testy potwierdzają, że zachowanie się nie zmieniło. Rodzaje testów układają się w piramidę. Na dole leżą testy jednostkowe (unit tests) jednej funkcji lub komponentu - najszybsze i najtańsze, więc piszesz ich najwięcej. Wyżej stoją testy integracyjne, sprawdzające kilka części naraz. Na szczycie są testy end-to-end (E2E), klikające po prawdziwej aplikacji w przeglądarce - najwolniejsze i najdroższe, więc wystarczy ich kilka dla najważniejszych ścieżek.

Vitest - Framework Testowy

Vitest to nowoczesny framework testowy dla Vue, polecany przez dokumentację Vue w projektach opartych na Vite:

  • Szybki jak Vite
  • Kompatybilny z Jest
  • Natywne ESM
  • TypeScript out-of-the-box

Szybkość bierze się stąd, że Vitest korzysta z tej samej konfiguracji i przetwarzania plików co Vite, więc od razu rozumie pliki .vue, a API zgodne z Jest sprawia, że describe, it i expect wyglądają znajomo.

Instalacja

Do Vitest dokładamy dwie paczki: Vue Test Utils (@vue/test-utils), oficjalną bibliotekę do montowania i testowania komponentów Vue w izolacji, oraz happy-dom, który symuluje DOM przeglądarki w Node.js:

npm install -D vitest @vue/test-utils happy-dom

Flaga -D zapisuje paczki w devDependencies - narzędzia laboratorium nie trafią do buildu produkcyjnego. Wtyczkę @vitejs/plugin-vue projekt na Vite już ma.

Konfiguracja

W pliku vitest.config.js sekcja test włącza globals: true, dzięki czemu describe, it i expect działają bez importu, oraz environment: 'happy-dom', czyli symulowany DOM:

// vitest.config.js
import { defineConfig } from 'vitest/config'
import vue from '@vitejs/plugin-vue'

export default defineConfig({
  plugins: [vue()],
  test: {
    globals: true,
    environment: 'happy-dom'
  }
})

Sekcję test możesz też dopisać do vite.config.js; gdy istnieją oba pliki, wygrywa vitest.config.js. Zostają skrypty w package.json:

// package.json
{
  "scripts": {
    "test": "vitest",
    "test:ui": "vitest --ui",
    "test:coverage": "vitest --coverage"
  }
}

Polecenie vitest działa w trybie obserwacji i powtarza testy po każdej zmianie, a w CI uruchamia je jednorazowo. vitest --ui otwiera panel w przeglądarce i wymaga paczki @vitest/ui. vitest --coverage mierzy pokrycie kodu testami, czyli procent instrukcji, gałęzi, funkcji i linii kodu źródłowego wykonanych przez testy; potrzebuje paczki @vitest/coverage-v8.

Testowany komponent

Sprawdzać będziemy prosty licznik z przyciskami + i - oraz propsem initialCount:

<!-- Counter.vue -->
<template>
  <div class="counter">
    <p>Count: {{ count }}</p>
    <button class="increment" @click="count++">+</button>
    <button class="decrement" @click="count--">-</button>
  </div>
</template>

<script setup>
import { ref } from 'vue'

const props = defineProps({
  initialCount: {
    type: Number,
    default: 0
  }
})

const count = ref(props.initialCount)
</script>

Licznik trzyma stan w ref, a prop jest tylko wartością startową. Klasy przycisków posłużą testom za selektory.

Pierwszy Test

Test buduje się z trzech funkcji Vitest: describe grupuje przypadki pod wspólną nazwą, it opisuje jeden przypadek, a expect stawia warunek na wyniku za pomocą matchera, na przykład toContain. Funkcja mount z Vue Test Utils montuje komponent i zwraca wrapper - obiekt, przez który czytasz tekst metodą text() i szukasz elementów metodą find():

// components/Counter.spec.js
import { describe, it, expect } from 'vitest'
import { mount } from '@vue/test-utils'
import Counter from './Counter.vue'

describe('Counter', () => {
  it('renders count', () => {
    const wrapper = mount(Counter)
    expect(wrapper.text()).toContain('Count: 0')
  })

Test montuje licznik bez propsów i sprawdza jego tekst - bez przeglądarki, w symulowanym DOM. Drugi przypadek symuluje kliknięcie: find przyjmuje selektor CSS, a trigger('click') wysyła zdarzenie do znalezionego przycisku:

  // Counter.spec.js - dalszy ciąg describe('Counter')
  it('increments count on button click', async () => {
    const wrapper = mount(Counter)

    await wrapper.find('button.increment').trigger('click')

    expect(wrapper.text()).toContain('Count: 1')
  })

Słowo await jest konieczne: Vue aktualizuje DOM asynchronicznie, a trigger zwraca obietnicę spełnianą dopiero po przerysowaniu. Bez niego asercja przeczytałaby stary tekst Count: 0. Trzeci przypadek przekazuje prop w polu props obiektu opcji, czyli drugiego argumentu mount:

  // Counter.spec.js - dalszy ciąg describe('Counter')
  it('accepts initial count prop', () => {
    const wrapper = mount(Counter, {
      props: {
        initialCount: 10
      }
    })

    expect(wrapper.text()).toContain('Count: 10')
  })
})

Ostatni nawias zamyka blok describe. Zwróć uwagę, czego test nie sprawdza: nie zagląda do zmiennej count, tylko do tekstu widocznego dla użytkownika, więc przetrwa zmianę implementacji.

Testowanie zdarzeń

Komponenty także emitują zdarzenia. Metoda emitted() zwraca obiekt wszystkich wyemitowanych zdarzeń, a emitted('select') tablicę emisji jednego zdarzenia, w której każda emisja jest tablicą argumentów. Samo wrapper.trigger klika główny element komponentu:

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

describe('ArtworkCard', () => {
  it('emits select event on click', async () => {
    const artwork = {
      id: 1,
      title: 'Mona Lisa',
      artist: 'Leonardo'
    }

    const wrapper = mount(ArtworkCard, {
      props: { artwork }
    })

    await wrapper.trigger('click')

    expect(wrapper.emitted()).toHaveProperty('select')
    expect(wrapper.emitted('select')[0]).toEqual([artwork])
  })

  it('emits favorite event on heart click', async () => {
    const wrapper = mount(ArtworkCard, {
      props: {
        artwork: { id: 1, title: 'Test' }
      }
    })

    await wrapper.find('.favorite-btn').trigger('click')

    expect(wrapper.emitted('favorite')).toBeTruthy()
  })
})

Wyrażenie emitted('select')[0] to pierwsza emisja, a matcher toEqual porównuje jej zawartość, nie tożsamość obiektu - więcej o tym w następnej lekcji. Gdy zdarzenie nie padło, emitted('favorite') zwraca undefined, więc toBeTruthy() sprawdza, że wystąpiło. Brak importu describe, it i expect nie przeszkadza dzięki globals: true.

Testowanie slotów

Treść slotów przekazujesz w opcji slots: kluczem jest nazwa slotu, a wartością fragment HTML. Slot bez nazwy nazywa się default:

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

describe('BaseCard', () => {
  it('renders default slot', () => {
    const wrapper = mount(BaseCard, {
      slots: {
        default: '<p>Test content</p>'
      }
    })

    expect(wrapper.html()).toContain('Test content')
  })

  it('renders named slots', () => {
    const wrapper = mount(BaseCard, {
      slots: {
        header: '<h2>Header</h2>',
        default: '<p>Body</p>',
        footer: '<footer>Footer</footer>'
      }
    })

    expect(wrapper.find('h2').text()).toBe('Header')
    expect(wrapper.find('p').text()).toBe('Body')
    expect(wrapper.find('footer').text()).toBe('Footer')
  })
})

Pierwszy przypadek sprawdza cały HTML metodą html(), drugi porównuje tekst konkretnych elementów matcherem toBe. Komponent BaseCard nie wie, że działa w teście - dostaje sloty tak jak od rodzica.

Moja rada: testuj zachowanie widoczne z zewnątrz - tekst, zdarzenia i sloty - a nie wewnętrzne zmienne komponentu, bo taki test przeżyje refactoring. W następnej lekcji zejdziesz pod podłogę panelu i sprawdzisz composables oraz store Pinia.

Zapamiętaj: test to procedura przedstartowa zapisana w kodzie - każdy moduł przechodzi ją, zanim poleci na Marsa.

Kod do tej lekcji: App.vue
<script setup>
import { ref, computed } from 'vue'

// NOVA LAB - demo konfiguracji buildu
const buildConfig = ref({
  mode: 'production',
  minify: true,
  sourceMap: false,
  chunkSize: 500,
  compression: 'gzip'
})

const buildStats = computed(() => {
  let size = 1200 // bazowy rozmiar w KB
  if (buildConfig.value.minify) size *= 0.6
  if (buildConfig.value.compression === 'gzip') size *= 0.3
  if (buildConfig.value.compression === 'brotli') size *= 0.25
  return Math.round(size)
})

const optimizationScore = computed(() => {
  let score = 0
  if (buildConfig.value.mode === 'production') score += 25
  if (buildConfig.value.minify) score += 25
  if (!buildConfig.value.sourceMap) score += 20
  if (buildConfig.value.chunkSize <= 500) score += 15
  if (buildConfig.value.compression !== 'none') score += 15
  return score
})

function toggleMinify() {
  buildConfig.value.minify = !buildConfig.value.minify
}

function toggleSourceMap() {
  buildConfig.value.sourceMap = !buildConfig.value.sourceMap
}

function setCompression(type) {
  buildConfig.value.compression = type
}
</script>

<template>
  <div class="launch-control">
    <div class="header">
      <h1>NOVA LAB - konfiguracja buildu</h1>
      <p>Strefa Wyrzutni - Platforma Startowa</p>
    </div>

    <div class="config-panel">
      <h2>Ustawienia buildu</h2>

      <div class="setting">
        <label>
          <input type="checkbox" v-model="buildConfig.minify" @change="toggleMinify">
          Minifikacja (kompresja wlaczona)
        </label>
      </div>

      <div class="setting">
        <label>
          <input type="checkbox" v-model="buildConfig.sourceMap" @change="toggleSourceMap">
          Source maps (tryb debugowania)
        </label>
      </div>

      <div class="setting">
        <label>Typ kompresji:</label>
        <select v-model="buildConfig.compression">
          <option value="none">Brak</option>
          <option value="gzip">GZIP</option>
          <option value="brotli">Brotli</option>
        </select>
      </div>

      <div class="setting">
        <label>Limit rozmiaru chunka (KB):</label>
        <input type="range" v-model.number="buildConfig.chunkSize" min="100" max="1000" step="50">
        <span>{{ buildConfig.chunkSize }} KB</span>
      </div>
    </div>

    <div class="stats-panel">
      <h2>Statystyki buildu</h2>
      <div class="stat">
        <span>Rozmiar paczki:</span>
        <strong :class="{ optimal: buildStats < 400 }">{{ buildStats }} KB</strong>
      </div>
      <div class="stat">
        <span>Wynik optymalizacji:</span>
        <strong :class="{ optimal: optimizationScore >= 80 }">{{ optimizationScore }}/100</strong>
      </div>
      <div class="status" :class="optimizationScore >= 80 ? 'ready' : 'warning'">
        {{ optimizationScore >= 80 ? 'Gotowe do startu!' : 'Wymaga optymalizacji' }}
      </div>
    </div>
  </div>
</template>

<style scoped>
.launch-control {
  background: linear-gradient(135deg, #0a0e27 0%, #1a1e3f 100%);
  color: #00ff88;
  padding: 2rem;
  min-height: 100vh;
  font-family: 'Courier New', monospace;
}

.header {
  text-align: center;
  margin-bottom: 2rem;
  border-bottom: 2px solid #00b4d8;
  padding-bottom: 1rem;
}

.header h1 {
  color: #00ff88;
  text-shadow: 0 0 10px #00ff88;
  margin: 0;
}

.header p {
  color: #00b4d8;
  margin: 0.5rem 0 0 0;
}

.config-panel, .stats-panel {
  background: rgba(0, 180, 216, 0.1);
  border: 1px solid #00b4d8;
  border-radius: 8px;
  padding: 1.5rem;
  margin-bottom: 1.5rem;
}

.config-panel h2, .stats-panel h2 {
  color: #00b4d8;
  margin-top: 0;
  font-size: 1.2rem;
}

.setting {
  margin-bottom: 1rem;
  padding: 0.75rem;
  background: rgba(0, 255, 136, 0.05);
  border-radius: 4px;
}

.setting label {
  display: flex;
  align-items: center;
  gap: 0.5rem;
  color: #00ff88;
}

.setting input[type="checkbox"] {
  width: 20px;
  height: 20px;
}

.setting select, .setting input[type="range"] {
  margin-left: 0.5rem;
  padding: 0.5rem;
  background: #0a0e27;
  border: 1px solid #00b4d8;
  color: #00ff88;
  border-radius: 4px;
}

.stat {
  display: flex;
  justify-content: space-between;
  padding: 0.75rem;
  margin-bottom: 0.5rem;
  background: rgba(0, 255, 136, 0.05);
  border-radius: 4px;
}

.stat strong {
  color: #fff;
  font-size: 1.2rem;
}

.stat strong.optimal {
  color: #00ff88;
  text-shadow: 0 0 5px #00ff88;
}

.status {
  text-align: center;
  padding: 1rem;
  margin-top: 1rem;
  border-radius: 4px;
  font-size: 1.1rem;
  font-weight: bold;
}

.status.ready {
  background: rgba(0, 255, 136, 0.2);
  color: #00ff88;
  border: 2px solid #00ff88;
}

.status.warning {
  background: rgba(255, 165, 0, 0.2);
  color: #ffa500;
  border: 2px solid #ffa500;
}
</style>

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Dlaczego testowanie jest kluczowe w aplikacjach Vue?

  2. 2. Dlaczego Vitest jest zalecanym frameworkiem testowym dla Vue + Vite?

To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij plik konfiguracyjny vitest.config.js, aby poprawnie skonfigurować środowisko testowe Vue.

  • Klikanie w kolejności

    Ułóż elementy struktury testu w poprawnej kolejności:

  • Edytor kodu

    Napisz test sprawdzający czy komponent Counter renderuje się poprawnie i reaguje na kliknięcie.

  • Układanie w pionie

    Uporządkuj kroki pisania testu komponentu Vue:

  • Układanie w poziomie

    Ułóż składnię montowania komponentu z props w teście:

  • Edytor kodu

    Napisz test sprawdzający czy komponent emituje event 'select' po kliknięciu i przekazuje dane artwork.

  • Układanie w pionie

    Ułóż typy testów od najszybszych i najtańszych do najwolniejszych i najdroższych:

  • Klikanie w kolejności

    Ułóż kod symulujący kliknięcie przycisku w teście:

  1. PytanieZalety testowania
  2. PytanieFramework testowy Vitest
  3. Zadanie z kodemPraktyka: Konfiguracja Vitest
  4. PytanieRola Vue Test Utils
  5. Kliknij w kolejnościStruktura testu Vitest
  6. Zadanie z kodemPraktyka: Pierwszy test komponentu
  7. Ułóż w kolejnościEtapy pisania testu komponentu
  8. PytanieTestowanie emitowanych eventów
  9. Ułóż w kolejnościMontowanie komponentu z props
  10. Zadanie z kodemPraktyka: Testowanie eventów
  11. Ułóż w kolejnościPiramida testowania
  12. PytanieTestowanie slotów
  13. Kliknij w kolejnościSymulacja kliknięcia w teście

Przydatne artykuły