Kurs Vue.js · Moduł 9: Composables i VueUse

Testowanie Composables

8 min czytania ·
W tej lekcji6

Każdy krytyczny system stacji NOVA LAB musi przejść rygorystyczne testy przed wdrożeniem. Tak samo composables - musimy mieć pewność, że działają poprawnie w każdym scenariuszu. Pomyśl o skali: jeden composable pracuje w dziesięciu komponentach, więc jeden błąd w nim psuje dziesięć ekranów naraz. Test napisany na poziomie composable łapie taki błąd jednym uruchomieniem, zanim zobaczy go załoga.

Przygotowanie środowiska testowego

Do testowania composables używamy Vitest, czyli narzędzia do testów z ekosystemu Vite, a pomocnicze funkcje, takie jak flushPromises, daje pakiet @vue/test-utils. Dokumentacja Vue rozróżnia dwa przypadki. Composable, który używa tylko ref, computed i watch, możesz po prostu wywołać w teście. Composable z hookami cyklu życia albo z inject potrzebuje komponentu-gospodarza, a tego dostarcza funkcja pomocnicza, która uruchamia go wewnątrz komponentu testowego:

// test-utils.ts
import { createApp, defineComponent } from 'vue'

// Helper: uruchom composable w izolowanym komponencie
export function withSetup(composable) {
  let result

  const TestComponent = defineComponent({
    setup() {
      result = composable()
      return () => {} // pusty render
    }
  })

  const app = createApp(TestComponent)
  app.mount(document.createElement('div'))

  return { result, app }
}

Komponent testowy wywołuje composable w setup, renderuje pustą funkcję i zostaje zamontowany w elemencie, którego nie ma na żadnej stronie. document istnieje w teście dzięki symulacji DOM, więc w konfiguracji Vitest ustaw test.environment na 'happy-dom' albo 'jsdom'. Zwracany app przyda się do odmontowania.

Testowanie prostego composable

Zacznijmy od licznika. W pliku testów importujesz funkcje Vitest, sam composable i helper:

import { describe, it, expect } from 'vitest'
import { ref } from 'vue'
import { withSetup } from './test-utils'

// Composable do testowania
function useCounter(initial = 0) {
  const count = ref(initial)
  const increment = () => count.value++
  const decrement = () => count.value--
  const reset = () => { count.value = initial }
  return { count, increment, decrement, reset }
}

describe grupuje testy jednego composable, każde it to osobny scenariusz, a expect(...).toBe(...) porównuje wynik z oczekiwaną wartością:

describe('useCounter', () => {
  it('startuje z wartością początkową', () => {
    const { result } = withSetup(() => useCounter(10))
    expect(result.count.value).toBe(10)
  })

  it('domyślnie startuje od 0', () => {
    const { result } = withSetup(() => useCounter())
    expect(result.count.value).toBe(0)
  })

  it('inkrementuje wartość', () => {
    const { result } = withSetup(() => useCounter())
    result.increment()
    expect(result.count.value).toBe(1)
    result.increment()
    expect(result.count.value).toBe(2)
  })

  it('dekrementuje wartość', () => {
    const { result } = withSetup(() => useCounter(5))
    result.decrement()
    expect(result.count.value).toBe(4)
  })

  it('resetuje do wartości początkowej', () => {
    const { result } = withSetup(() => useCounter(10))
    result.increment()
    result.increment()
    result.reset()
    expect(result.count.value).toBe(10)
  })
})

Każdy test tworzy świeży licznik, więc wynik jednego nie wpływa na drugi. Ten composable używa tylko ref, więc zadziałałby też bez helpera; używamy go dla spójności z kolejnymi przykładami.

Mockowanie reaktywnych zależności

Gdy composable zależy od zewnętrznych źródeł danych, mockujemy je. Najłatwiej, gdy zależność przychodzi jako parametr - tu funkcja fetchFn:

import { describe, it, expect, vi } from 'vitest'
import { ref, nextTick } from 'vue'
import { withSetup } from './test-utils'

// Composable z zależnością od fetch
function useSensorData(fetchFn) {
  const data = ref(null)
  const error = ref(null)
  const loading = ref(false)

  async function load(sensorId) {
    loading.value = true
    error.value = null
    try {
      data.value = await fetchFn(sensorId)
    } catch (e) {
      error.value = e.message
    } finally {
      loading.value = false
    }
  }

  return { data, error, loading, load }
}

vi.fn() tworzy funkcję-atrapę, która zapamiętuje swoje wywołania. mockResolvedValue każe jej zwrócić obietnicę spełnioną podanym obiektem, a mockRejectedValue - odrzuconą błędem:

describe('useSensorData', () => {
  it('ładuje dane z serwera', async () => {
    // Mock funkcji fetch
    const mockFetch = vi.fn().mockResolvedValue({
      id: 'T-01',
      temperature: 22,
      status: 'active'
    })

    const { result } = withSetup(() => useSensorData(mockFetch))

    expect(result.loading.value).toBe(false)

    await result.load('T-01')

    expect(mockFetch).toHaveBeenCalledWith('T-01')
    expect(result.data.value).toEqual({
      id: 'T-01',
      temperature: 22,
      status: 'active'
    })
    expect(result.loading.value).toBe(false)
  })

  it('obsługuje błędy', async () => {
    const mockFetch = vi.fn().mockRejectedValue(
      new Error('Serwer niedostępny')
    )

    const { result } = withSetup(() => useSensorData(mockFetch))

    await result.load('T-01')

    expect(result.error.value).toBe('Serwer niedostępny')
    expect(result.data.value).toBeNull()
  })
})

toHaveBeenCalledWith sprawdza argumenty wywołania, a toEqual porównuje obiekty pole po polu, bo toBe wymagałby tej samej referencji. Żaden test nie dotknął prawdziwego serwera.

Testowanie composables z watch

Tu kryje się ważna różnica. computed przelicza się synchronicznie w chwili odczytu, a callback watch Vue odkłada do następnego ticka, czyli do chwili, gdy skończy się bieżący synchroniczny kod. Dlatego do filtra dokładamy licznik wyszukiwań prowadzony przez watch:

import { describe, it, expect } from 'vitest'
import { ref, watch, nextTick, computed } from 'vue'
import { withSetup } from './test-utils'

function useSearchFilter(items) {
  const query = ref('')
  const searchCount = ref(0)

  const filtered = computed(() => {
    if (!query.value) return items.value
    return items.value.filter(item =>
      item.name.toLowerCase().includes(query.value.toLowerCase())
    )
  })

  // watch liczy zmiany zapytania - jego callback czeka na następny tick
  watch(query, () => {
    searchCount.value++
  })

  return { query, filtered, searchCount }
}

Nazwa i zapytanie są porównywane małymi literami, więc wielkość liter nie ma znaczenia - test na zapytanie 'TEMP' dopiszesz w zadaniu praktycznym. Trzeci test poniżej pokazuje, po co jest nextTick:

describe('useSearchFilter', () => {
  it('filtruje elementy po zapytaniu', async () => {
    const items = ref([
      { name: 'Sensor temperatury' },
      { name: 'Sensor ciśnienia' },
      { name: 'Sensor radiacji' }
    ])

    const { result } = withSetup(() => useSearchFilter(items))

    // Początkowo wszystkie elementy
    expect(result.filtered.value).toHaveLength(3)

    // Filtrowanie
    result.query.value = 'temp'
    await nextTick()

    expect(result.filtered.value).toHaveLength(1)
    expect(result.filtered.value[0].name).toBe('Sensor temperatury')
  })

  it('zwraca wszystko dla pustego zapytania', async () => {
    const items = ref([{ name: 'A' }, { name: 'B' }])
    const { result } = withSetup(() => useSearchFilter(items))

    result.query.value = 'A'
    await nextTick()
    expect(result.filtered.value).toHaveLength(1)

    result.query.value = ''
    await nextTick()
    expect(result.filtered.value).toHaveLength(2)
  })

  it('liczy zmiany zapytania dopiero po nextTick', async () => {
    const items = ref([{ name: 'A' }])
    const { result } = withSetup(() => useSearchFilter(items))

    result.query.value = 'A'
    expect(result.searchCount.value).toBe(0) // watch jeszcze nie ruszył

    await nextTick()
    expect(result.searchCount.value).toBe(1)
  })
})

W dwóch pierwszych testach filtered dałby poprawny wynik nawet bez await nextTick(), bo to computed. W trzecim bez oczekiwania licznik zostaje na zerze. flushPromises z @vue/test-utils idzie o krok dalej: czeka, aż rozwiążą się wszystkie oczekujące obietnice.

Testowanie composables asynchronicznych

Composable odpytujący serwer co kilka sekund testujemy na fałszywych zegarach Vitest, żeby test nie czekał naprawdę. Tak wygląda badany kod:

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { ref, onMounted, onUnmounted } from 'vue'
import { withSetup } from './test-utils'

function usePolling(fetchFn, interval = 5000) {
  const data = ref(null)
  const isPolling = ref(false)
  let timerId = null

  function startPolling() {
    isPolling.value = true
    timerId = setInterval(async () => {
      data.value = await fetchFn()
    }, interval)
  }

  function stopPolling() {
    isPolling.value = false
    if (timerId) {
      clearInterval(timerId)
      timerId = null
    }
  }

  onUnmounted(stopPolling)

  return { data, isPolling, startPolling, stopPolling }
}

vi.useFakeTimers() podmienia setInterval na zegar, który przesuwamy ręcznie, a vi.useRealTimers() przywraca prawdziwy. advanceTimersByTimeAsync przesuwa czas i czeka też na obietnice zwrócone przez timery:

describe('usePolling', () => {
  beforeEach(() => {
    vi.useFakeTimers()
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  it('odpytuje serwer w zadanych odstępach', async () => {
    let callCount = 0
    const mockFetch = vi.fn().mockImplementation(() => {
      callCount++
      return Promise.resolve({ reading: callCount * 10 })
    })

    const { result } = withSetup(() => usePolling(mockFetch, 1000))

    result.startPolling()
    expect(result.isPolling.value).toBe(true)

    // Symulacja upływu czasu (wersja Async czeka też na obietnice)
    await vi.advanceTimersByTimeAsync(3000)

    expect(mockFetch).toHaveBeenCalledTimes(3)
    expect(result.data.value).toEqual({ reading: 30 })

    result.stopPolling()
    expect(result.isPolling.value).toBe(false)
  })

Po trzech symulowanych sekundach serwer odpowiedział trzy razy, a data trzyma ostatni odczyt. Synchroniczne advanceTimersByTime też wywołałoby mockFetch trzy razy, ale data zostałoby puste. Na koniec test sprzątania, w którym app.unmount() uruchamia onUnmounted:

  it('sprząta timer po odmontowaniu', async () => {
    const mockFetch = vi.fn().mockResolvedValue({ reading: 1 })
    const { result, app } = withSetup(() => usePolling(mockFetch, 1000))

    result.startPolling()
    app.unmount() // uruchamia onUnmounted -> stopPolling

    await vi.advanceTimersByTimeAsync(5000)
    expect(mockFetch).not.toHaveBeenCalled()
    expect(result.isPolling.value).toBe(false)
  })
})

Pięć sekund po odmontowaniu nikt nie odpytał serwera - timer naprawdę zniknął.

Dobre praktyki testowania

  1. Izolacja - każdy test powinien być niezależny
  2. Mockowanie - zewnętrzne zależności zawsze mockowane
  3. Asynchroniczność - używaj nextTick dla watcherów i aktualizacji DOM, a flushPromises dla oczekujących obietnic
  4. Cleanup - sprawdzaj czy composable poprawnie czyści zasoby, na przykład przez app.unmount()
  5. Edge cases - testuj puste dane, błędy, wartości graniczne

Moja rada: projektuj composables tak, by zależności przychodziły parametrami, jak fetchFn. Wtedy mock to jedna linijka, a test nie wymaga podmieniania globalnego fetch. Testy komponentów rozbudujesz na Platformie Startowej. W edytorze poniżej działa miniaturowy runner testów w przeglądarce: sprawdza useCounter, useSearchFilter i useAsyncData, a wyniki pokazuje na panelu.

Zapamiętaj: test to próba ciśnieniowa modułu przed startem - lepiej, żeby przeciek znalazł go w laboratorium niż na orbicie.

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

// ===== DEMO: TESTOWANIE COMPOSABLES =====

// Composable: useCounter (testowany)
function useCounter(initial = 0) {
  const count = ref(initial)
  const doubled = computed(() => count.value * 2)
  const increment = () => count.value++
  const decrement = () => count.value--
  const reset = () => { count.value = initial }
  return { count, doubled, increment, decrement, reset }
}

// Composable: useSearchFilter (testowany)
function useSearchFilter(items) {
  const query = ref('')
  const filtered = computed(() => {
    if (!query.value) return items.value
    return items.value.filter(item =>
      item.name.toLowerCase().includes(query.value.toLowerCase())
    )
  })
  return { query, filtered }
}

// Composable: useAsyncData (testowany)
function useAsyncData(fetchFn) {
  const data = ref(null)
  const error = ref(null)
  const loading = ref(false)

  async function load(...args) {
    loading.value = true
    error.value = null
    try {
      data.value = await fetchFn(...args)
    } catch (e) {
      error.value = e.message
    } finally {
      loading.value = false
    }
  }

  return { data, error, loading, load }
}

// === Mini runner testów ===
const testResults = ref([])
const totalPassed = computed(() => testResults.value.filter(t => t.passed).length)
const totalFailed = computed(() => testResults.value.filter(t => !t.passed).length)

function assert(condition, testName) {
  testResults.value.push({
    name: testName,
    passed: condition,
    timestamp: new Date().toLocaleTimeString()
  })
}

async function runAllTests() {
  testResults.value = []

  // Testy useCounter
  const counter = useCounter(10)
  assert(counter.count.value === 10, 'useCounter: startuje od wartości początkowej')
  counter.increment()
  assert(counter.count.value === 11, 'useCounter: increment działa')
  assert(counter.doubled.value === 22, 'useCounter: computed doubled działa')
  counter.decrement()
  counter.decrement()
  assert(counter.count.value === 9, 'useCounter: decrement działa')
  counter.reset()
  assert(counter.count.value === 10, 'useCounter: reset wraca do wartości początkowej')

  const defaultCounter = useCounter()
  assert(defaultCounter.count.value === 0, 'useCounter: domyślna wartość początkowa to 0')

  // Testy useSearchFilter
  const items = ref([
    { name: 'Czujnik temperatury' },
    { name: 'Czujnik ciśnienia' },
    { name: 'Detektor promieniowania' }
  ])
  const filter = useSearchFilter(items)
  assert(filter.filtered.value.length === 3, 'useSearchFilter: na start pokazuje wszystko')

  filter.query.value = 'czujnik'
  await nextTick()
  assert(filter.filtered.value.length === 2, 'useSearchFilter: filtruje według zapytania')

  filter.query.value = 'promieniowania'
  await nextTick()
  assert(filter.filtered.value.length === 1, 'useSearchFilter: dokładne dopasowanie')
  assert(filter.filtered.value[0].name === 'Detektor promieniowania', 'useSearchFilter: właściwy element')

  filter.query.value = ''
  await nextTick()
  assert(filter.filtered.value.length === 3, 'useSearchFilter: puste zapytanie pokazuje wszystko')

  // Testy useAsyncData
  const successData = useAsyncData(async () => ({ temp: 22, status: 'OK' }))
  assert(successData.loading.value === false, 'useAsyncData: na start nie ładuje')
  assert(successData.data.value === null, 'useAsyncData: na start brak danych')

  await successData.load()
  assert(successData.data.value !== null, 'useAsyncData: po load() są dane')
  assert(successData.data.value.temp === 22, 'useAsyncData: poprawne dane')
  assert(successData.error.value === null, 'useAsyncData: brak błędu po sukcesie')

  const failData = useAsyncData(async () => { throw new Error('Utracono połączenie') })
  await failData.load()
  assert(failData.error.value === 'Utracono połączenie', 'useAsyncData: przechwytuje błąd')
  assert(failData.data.value === null, 'useAsyncData: brak danych po błędzie')
}
</script>

<template>
  <div class="test-lab">
    <h1>Testowanie composables - NOVA LAB</h1>

    <div class="controls">
      <button @click="runAllTests" class="run-btn">Uruchom wszystkie testy</button>
    </div>

    <div v-if="testResults.length" class="summary">
      <span class="passed">Zaliczone: {{ totalPassed }}</span>
      <span class="failed">Niezaliczone: {{ totalFailed }}</span>
      <span class="total">Razem: {{ testResults.length }}</span>
    </div>

    <div class="results">
      <div v-for="(test, i) in testResults" :key="i"
        class="test-result" :class="{ pass: test.passed, fail: !test.passed }">
        <span class="icon">{{ test.passed ? 'OK' : 'BŁĄD' }}</span>
        <span class="test-name">{{ test.name }}</span>
      </div>
    </div>

    <div v-if="!testResults.length" class="empty">
      Kliknij "Uruchom wszystkie testy", aby wykonać zestaw testów
    </div>
  </div>
</template>

<style scoped>
.test-lab { background: #0a0e27; color: #e0e0ff; padding: 1.5rem; min-height: 100vh; font-family: 'Courier New', monospace; }
h1 { color: #00ff88; text-align: center; margin-bottom: 2rem; }
.controls { text-align: center; margin: 1rem 0; }
.run-btn { background: #00ff88; color: #0a0e27; border: none; padding: 0.8rem 2rem; border-radius: 6px; font-size: 1.1rem; font-weight: bold; cursor: pointer; font-family: inherit; }
.run-btn:hover { background: #00b4d8; color: #fff; }
.summary { display: flex; justify-content: center; gap: 2rem; padding: 1rem; background: rgba(0,0,0,0.3); border-radius: 8px; margin: 1rem 0; font-size: 1.1rem; }
.passed { color: #00ff88; }
.failed { color: #ff0055; }
.total { color: #00b4d8; }
.results { margin: 1rem 0; }
.test-result { display: flex; align-items: center; gap: 0.8rem; padding: 0.5rem 0.8rem; margin: 0.2rem 0; border-radius: 4px; font-size: 0.9rem; }
.test-result.pass { background: rgba(0,255,136,0.08); border-left: 3px solid #00ff88; }
.test-result.fail { background: rgba(255,0,85,0.08); border-left: 3px solid #ff0055; }
.icon { font-weight: bold; font-size: 0.8rem; padding: 0.15rem 0.4rem; border-radius: 3px; }
.pass .icon { background: #00ff88; color: #0a0e27; }
.fail .icon { background: #ff0055; color: #fff; }
.test-name { color: #ccc; }
.empty { text-align: center; color: #666; padding: 3rem; font-style: italic; }
</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 potrzebujemy helpera withSetup do testowania composables?

  2. 2. Jak mockujemy zewnętrzne zależności w testach composables?

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

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz komponent testowy z useSensorData. Zamockuj fetchFn za pomocą vi.fn(). Sprawdź loading, data, error po użyciu load().

  • Układanie w pionie

    Ułóż kroki unit testu composable od przygotowania do asercji:

  • Klikanie w kolejności

    Ułóż poprawną asercję sprawdzającą wartość ref:

  • Edytor kodu

    Przetestuj useSearchFilter: filtrowanie po zapytaniu, puste zapytanie zwraca wszystko, wielkość liter nie ma znaczenia.

  • Układanie w poziomie

    Ułóż tworzenie mocka funkcji fetch:

  1. PytanieHelper withSetup w testach
  2. PytanieMockowanie w testach composables
  3. Zadanie z kodemPraktyka: Test composable z mockiem
  4. Ułóż w kolejnościKroki testowania composable
  5. PytanienextTick w testach
  6. Kliknij w kolejnościAsercja w teście composable
  7. Zadanie z kodemPraktyka: Test useSearchFilter
  8. Ułóż w kolejnościMock funkcji w Vitest

Przydatne artykuły