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

Testing Integration & E2E

6 min czytania ·
W tej lekcji5

Testy integracyjne sprawdzają współpracę systemów - jak systemy rakiety współpracują przed startem na Marsa.

Każdy podzespół panelu przeszedł już próby w izolacji: licznik, composable, store archiwum. To jednak nie gwarantuje, że zadziałają razem. Komponent może czytać ze store'u pole o innej nazwie, niż store wystawia, a router może nie wyrenderować widoku, na który prowadzi link. Takich usterek nie złapie żaden test jednostkowy, bo pojawiają się dopiero na styku. Dlatego teraz składamy podzespoły z powrotem w całość.

Integracja a testy jednostkowe

Test jednostkowy sprawdza pojedynczą jednostkę w izolacji, a test integracyjny - współpracę wielu części naraz: komponentu ze store'em, komponentu z routerem, rodzica z dziećmi. Tu przydaje się różnica między dwiema funkcjami Vue Test Utils. mount() renderuje pełne drzewo komponentów razem z dziećmi, a shallowMount() zastępuje dzieci zaślepkami (stubami), które w HTML wyglądają jak <child-stub>. W teście integracyjnym używasz mount(), bo dzieci mają naprawdę działać.

Component Integration Tests

Pierwszy test sprawdza, czy galeria wyświetla dane ze store'u Pinia. Opcja global.plugins instaluje wtyczki w testowej aplikacji tak, jak robi to app.use() w main.js:

// ArtworkGallery.spec.js
import { describe, it, expect, beforeEach } from 'vitest'
import { mount } from '@vue/test-utils'
import { createPinia, setActivePinia } from 'pinia'
import ArtworkGallery from './ArtworkGallery.vue'
import { useGalleryStore } from '@/stores/gallery'

describe('ArtworkGallery Integration', () => {
  beforeEach(() => {
    setActivePinia(createPinia())
  })

  it('displays artworks from store', async () => {
    const wrapper = mount(ArtworkGallery, {
      global: {
        plugins: [createPinia()]
      }
    })

    const store = useGalleryStore()

    store.artworks = [
      { id: 1, title: 'Mona Lisa', artist: 'Leonardo' },
      { id: 2, title: 'David', artist: 'Michelangelo' }
    ]

    await wrapper.vm.$nextTick()

    const cards = wrapper.findAll('.artwork-card')
    expect(cards).toHaveLength(2)
  })

Instalacja Pinii przez global.plugins ustawia tę instancję jako aktywną, więc useGalleryStore() w teście i w komponencie trafia do tego samego magazynu. Po zmianie danych czekamy na $nextTick(), bo Vue przerysowuje DOM asynchronicznie. findAll zwraca listę pasujących elementów, a toHaveLength(2) sprawdza ich liczbę. Drugi przypadek dotyka trzech warstw naraz: pola wyszukiwania, gettera filtrującego w store'ze i listy kart. Metoda setValue wpisuje tekst do pola i wysyła zdarzenie input, tak jak zrobiłby to technik:

  // ArtworkGallery.spec.js - dalszy ciąg describe
  it('filters artworks on search input', async () => {
    const wrapper = mount(ArtworkGallery, {
      global: {
        plugins: [createPinia()]
      }
    })

    const store = useGalleryStore()
    store.artworks = [
      { id: 1, title: 'Mona Lisa', artist: 'Leonardo' },
      { id: 2, title: 'David', artist: 'Michelangelo' }
    ]

    await wrapper.vm.$nextTick()

    const searchInput = wrapper.find('input[type="search"]')
    await searchInput.setValue('mona')

    await wrapper.vm.$nextTick()

    const cards = wrapper.findAll('.artwork-card')
    expect(cards).toHaveLength(1)
    expect(cards[0].text()).toContain('Mona Lisa')
  })
})

Test nie wywołuje gettera bezpośrednio, tylko przechodzi przez interfejs, więc sprawdza także, czy szablon jest naprawdę podpięty do store'u. Sam store nie został niczym zastąpiony - to ten sam kod, który poleci na Marsa.

Router Integration

Komponent z <RouterView> potrzebuje działającego routera. W teście tworzysz go funkcją createRouter z historią createMemoryHistory, która trzyma adres w pamięci zamiast w pasku przeglądarki, a potem montujesz aplikację z routerem w global.plugins:

import { mount } from '@vue/test-utils'
import { createRouter, createMemoryHistory } from 'vue-router'
import App from './App.vue'

describe('App with Router', () => {
  it('navigates to gallery page', async () => {
    const router = createRouter({
      history: createMemoryHistory(),
      routes: [
        { path: '/', component: { template: '<div>Home</div>' } },
        { path: '/gallery', component: { template: '<div>Gallery</div>' } }
      ]
    })

    const wrapper = mount(App, {
      global: {
        plugins: [router]
      }
    })

    await router.push('/gallery')
    await router.isReady()

    expect(wrapper.html()).toContain('Gallery')
  })
})

router.push zwraca obietnicę nawigacji, a router.isReady() czeka na zakończenie pierwszej nawigacji, dlatego oba wywołania mają await. Zastępcze widoki zapisane jako obiekt z polem template wystarczają w teście; w aplikacji budowanej przez Vite użyjesz plików .vue, bo domyślna przeglądarkowa wersja Vue nie kompiluje szablonów w locie.

E2E Tests (Cypress/Playwright)

Testy E2E działają piętro wyżej: uruchamiają prawdziwą przeglądarkę, otwierają aplikację pod adresem i klikają jak człowiek. Nie montujesz tu komponentów - odwiedzasz stronę. Dokumentacja Vue poleca do tego Playwright oraz Cypress, a kreator create-vue proponuje Playwright już przy tworzeniu projektu. Tak wygląda scenariusz w Cypress:

// cypress/e2e/gallery.cy.js
describe('Gallery E2E', () => {
  beforeEach(() => {
    cy.visit('/')
  })

  it('displays artworks', () => {
    cy.get('.artwork-card').should('have.length.greaterThan', 0)
  })

  it('filters artworks by search', () => {
    cy.get('input[type="search"]').type('mona')

    cy.get('.artwork-card').should('have.length', 1)
    cy.get('.artwork-card').first().should('contain', 'Mona Lisa')
  })

cy.visit('/') otwiera stronę względem adresu bazowego (baseUrl) z konfiguracji Cypress. Asercje should ponawiają się same, aż warunek się spełni albo minie limit czasu, więc nie czekasz ręcznie na render. Kolejne przypadki idą dalej ścieżką operatora - do szczegółów obrazu i ulubionych:

  // cypress/e2e/gallery.cy.js - dalszy ciąg describe
  it('opens artwork detail on click', () => {
    cy.get('.artwork-card').first().click()

    cy.url().should('include', '/artwork/')
    cy.get('.artwork-detail').should('be.visible')
  })

  it('adds artwork to favorites', () => {
    cy.get('.artwork-card').first().find('.favorite-btn').click()

    cy.get('.favorites-count').should('contain', '1')
  })
})

Test nie zna żadnego komponentu, store'u ani trasy - widzi tylko to co użytkownik: adres, elementy i ich tekst.

Playwright Example

Ten sam scenariusz w Playwright. Każdy test dostaje obiekt page, czyli kartę przeglądarki, a kroki są zawsze te same: otwórz aplikację (page.goto), znajdź element (page.locator), wykonaj akcję (click, fill) i sprawdź wynik (expect):

// tests/gallery.spec.js
import { test, expect } from '@playwright/test'

test.describe('Gallery', () => {
  test('should display artworks', async ({ page }) => {
    await page.goto('/')

    const cards = page.locator('.artwork-card')
    await expect(cards).toHaveCount(12)
  })

  test('should filter artworks', async ({ page }) => {
    await page.goto('/')

    await page.locator('input[type="search"]').fill('leonardo')

    const cards = page.locator('.artwork-card')
    await expect(cards).toHaveCount(2)
  })

Metody page.fill() i page.click() z selektorem w argumencie wciąż istnieją, ale dokumentacja Playwright oznacza je jako odradzane i zaleca akcje na lokatorach, takie jak locator.fill(). Asercje w rodzaju toHaveCount same czekają na spełnienie warunku. Trzeci test przechodzi do szczegółów: first() wybiera pierwszy pasujący element, a toHaveURL sprawdza adres wyrażeniem regularnym:

  // tests/gallery.spec.js - dalszy ciąg test.describe
  test('should navigate to artwork detail', async ({ page }) => {
    await page.goto('/')

    await page.locator('.artwork-card').first().click()

    await expect(page).toHaveURL(/.*artwork\/\d+/)
    await expect(page.locator('.artwork-detail')).toBeVisible()
  })
})

Asercja toBeVisible potwierdza, że panel szczegółów faktycznie widać. Najkrótszy test dymny sprawdza tytuł karty przeglądarki asercją toHaveTitle:

test('shows the gallery title', async ({ page }) => {
  await page.goto('/')
  await expect(page).toHaveTitle('Gallery')
})

Tytuł pochodzi z elementu <title> w index.html, więc gdy ten test nie przejdzie, aplikacja najpewniej w ogóle nie wystartowała. Wszystkie testy wołają page.goto('/') ze ścieżką względną, co działa tylko z adresem bazowym w playwright.config.js:

// playwright.config.js
import { defineConfig } from '@playwright/test'

export default defineConfig({
  use: {
    baseURL: 'http://localhost:4173'
  },
  webServer: {
    command: 'npm run build && npm run preview',
    url: 'http://localhost:4173'
  }
})

Sekcja webServer każe Playwright samemu zbudować aplikację i podnieść vite preview, którego domyślnym portem jest 4173 - testujesz więc dokładnie ten ładunek, który poleci na produkcję.

Moja rada: trzymaj proporcje piramidy - dziesiątki testów jednostkowych, kilka integracyjnych dla kluczowych połączeń i garść testów E2E dla ścieżek, bez których misja traci sens. Raport pokrycia z Vitest podpowie, których miejsc kodu nie odwiedził jeszcze żaden test. Gdy wszystko świeci na zielono, zostaje zbudować ładunek do wysyłki - tym zajmiemy się w następnej lekcji.

Zapamiętaj: testy jednostkowe sprawdzają zawory, integracyjne całe instalacje, a E2E to lot próbny całej rakiety.

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

// NOVA LAB - lista kontrolna buildu produkcyjnego
const checklist = ref([
  { id: 1, task: 'Usun wywolania console.log', completed: false, critical: true },
  { id: 2, task: 'Wlacz tryb produkcyjny', completed: false, critical: true },
  { id: 3, task: 'Zoptymalizuj obrazy i zasoby', completed: false, critical: false },
  { id: 4, task: 'Wlacz HTTPS/SSL', completed: false, critical: true },
  { id: 5, task: 'Skonfiguruj sledzenie bledow', completed: false, critical: false },
  { id: 6, task: 'Skonfiguruj CDN', completed: false, critical: false },
  { id: 7, task: 'Wlacz kompresje (gzip/brotli)', completed: false, critical: true },
  { id: 8, task: 'Przetestuj na wielu urzadzeniach', completed: false, critical: false },
  { id: 9, task: 'Skonfiguruj monitoring', completed: false, critical: false },
  { id: 10, task: 'Skonfiguruj naglowki cache', completed: false, critical: true },
  { id: 11, task: 'Sprawdz naglowki bezpieczenstwa', completed: false, critical: true },
  { id: 12, task: 'Zrob kopie zapasowa danych produkcyjnych', completed: false, critical: true }
])

const completedCount = computed(() => {
  return checklist.value.filter(item => item.completed).length
})

const criticalCompleted = computed(() => {
  const critical = checklist.value.filter(item => item.critical)
  const completed = critical.filter(item => item.completed)
  return completed.length
})

const criticalTotal = computed(() => {
  return checklist.value.filter(item => item.critical).length
})

const progress = computed(() => {
  return Math.round((completedCount.value / checklist.value.length) * 100)
})

const isReadyForLaunch = computed(() => {
  return criticalCompleted.value === criticalTotal.value
})

function toggleTask(id) {
  const task = checklist.value.find(item => item.id === id)
  if (task) {
    task.completed = !task.completed
  }
}

function resetChecklist() {
  checklist.value.forEach(item => {
    item.completed = false
  })
}
</script>

<template>
  <div class="checklist-app">
    <div class="header">
      <h1>Lista kontrolna przed startem</h1>
      <p>Wdrozenie produkcyjne NOVA LAB</p>
    </div>

    <div class="progress-panel">
      <div class="progress-bar">
        <div class="progress-fill" :style="{ width: progress + '%' }"></div>
      </div>
      <div class="progress-stats">
        <span>Razem: {{ completedCount }}/{{ checklist.length }}</span>
        <span>Krytyczne: {{ criticalCompleted }}/{{ criticalTotal }}</span>
        <span>{{ progress }}%</span>
      </div>
    </div>

    <div class="launch-status" :class="isReadyForLaunch ? 'ready' : 'not-ready'">
      <template v-if="isReadyForLaunch">
        WSZYSTKIE SYSTEMY GOTOWE! Mozna wdrazac!
      </template>
      <template v-else>
        Pozostale zadania krytyczne: {{ criticalTotal - criticalCompleted }}
      </template>
    </div>

    <div class="checklist">
      <div
        v-for="item in checklist"
        :key="item.id"
        class="checklist-item"
        :class="{
          completed: item.completed,
          critical: item.critical && !item.completed
        }"
        @click="toggleTask(item.id)"
      >
        <div class="checkbox">
          <span v-if="item.completed">x</span>
        </div>
        <div class="task-content">
          <span class="task-text">{{ item.task }}</span>
          <span v-if="item.critical" class="badge">KRYTYCZNE</span>
        </div>
      </div>
    </div>

    <div class="actions">
      <button @click="resetChecklist" class="reset-btn">
        Resetuj liste
      </button>
    </div>
  </div>
</template>

<style scoped>
.checklist-app {
  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;
}

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

.progress-bar {
  height: 30px;
  background: rgba(0, 255, 136, 0.1);
  border-radius: 15px;
  overflow: hidden;
  margin-bottom: 1rem;
  border: 1px solid #00b4d8;
}

.progress-fill {
  height: 100%;
  background: linear-gradient(90deg, #00b4d8, #00ff88);
  transition: width 0.5s ease;
  box-shadow: 0 0 10px #00ff88;
}

.progress-stats {
  display: flex;
  justify-content: space-between;
  color: #00b4d8;
  font-size: 0.9rem;
}

.launch-status {
  text-align: center;
  padding: 1.5rem;
  margin-bottom: 1.5rem;
  border-radius: 8px;
  font-size: 1.2rem;
  font-weight: bold;
}

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

.launch-status.not-ready {
  background: rgba(255, 165, 0, 0.2);
  color: #ffa500;
  border: 2px solid #ffa500;
}

.checklist {
  display: flex;
  flex-direction: column;
  gap: 0.75rem;
  margin-bottom: 2rem;
}

.checklist-item {
  display: flex;
  align-items: center;
  gap: 1rem;
  padding: 1rem;
  background: rgba(0, 180, 216, 0.1);
  border: 1px solid #00b4d8;
  border-radius: 8px;
  cursor: pointer;
  transition: all 0.3s;
}

.checklist-item:hover {
  background: rgba(0, 180, 216, 0.2);
  transform: translateX(5px);
}

.checklist-item.completed {
  background: rgba(0, 255, 136, 0.1);
  border-color: #00ff88;
}

.checklist-item.critical {
  border-color: #ffa500;
  border-width: 2px;
}

.checkbox {
  width: 24px;
  height: 24px;
  border: 2px solid #00b4d8;
  border-radius: 4px;
  display: flex;
  align-items: center;
  justify-content: center;
  font-size: 1.2rem;
  flex-shrink: 0;
}

.completed .checkbox {
  background: #00ff88;
  border-color: #00ff88;
  color: #0a0e27;
}

.task-content {
  flex: 1;
  display: flex;
  justify-content: space-between;
  align-items: center;
}

.task-text {
  color: #fff;
}

.completed .task-text {
  text-decoration: line-through;
  opacity: 0.7;
}

.badge {
  background: #ffa500;
  color: #0a0e27;
  padding: 0.25rem 0.75rem;
  border-radius: 12px;
  font-size: 0.75rem;
  font-weight: bold;
}

.actions {
  text-align: center;
}

.reset-btn {
  padding: 1rem 2rem;
  background: rgba(0, 180, 216, 0.2);
  border: 2px solid #00b4d8;
  color: #00b4d8;
  font-size: 1rem;
  font-family: 'Courier New', monospace;
  border-radius: 8px;
  cursor: pointer;
  transition: all 0.3s;
}

.reset-btn:hover {
  background: #00b4d8;
  color: #0a0e27;
  box-shadow: 0 0 20px #00b4d8;
}
</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. Czym różnią się testy integracyjne od unit testów?

  2. 2. Jaka jest różnica między mount() a shallowMount() w Vue Test Utils?

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

Zadania praktyczne w grze

  • Edytor kodu

    Napisz test integracyjny komponentu z Pinia store - sprawdź czy komponent wyświetla dane ze store.

  • Układanie w pionie

    Uporządkuj kroki testu end-to-end:

  • Klikanie w kolejności

    Ułóż kod Playwright otwierający stronę i sprawdzający tytuł:

  • Edytor kodu

    Napisz test Playwright sprawdzający filtrowanie galerii - wpisanie tekstu w search i weryfikację wyników.

  • Układanie w poziomie

    Ułóż kod montowania komponentu z routerem w teście:

  1. PytanieCzym są testy integracyjne
  2. Pytaniemount() vs shallowMount()
  3. Zadanie z kodemPraktyka: Test integracji z Pinia
  4. Ułóż w kolejnościKroki testu E2E
  5. PytaniePlaywright - narzędzie E2E
  6. Kliknij w kolejnościPlaywright - nawigacja i asercja
  7. Zadanie z kodemPraktyka: Test E2E z Playwright
  8. Ułóż w kolejnościRouter test - mount z pluginem
  9. PytanieTest coverage

Przydatne artykuły