Kurs Vue.js · Moduł 9: Composables i VueUse
Testowanie Composables
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
- Izolacja - każdy test powinien być niezależny
- Mockowanie - zewnętrzne zależności zawsze mockowane
- Asynchroniczność - używaj
nextTickdla watcherów i aktualizacji DOM, aflushPromisesdla oczekujących obietnic - Cleanup - sprawdzaj czy composable poprawnie czyści zasoby, na przykład przez
app.unmount() - 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. Dlaczego potrzebujemy helpera withSetup do testowania composables?
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:
Zadania po tej lekcji
- PytanieHelper withSetup w testach
- PytanieMockowanie w testach composables
- Zadanie z kodemPraktyka: Test composable z mockiem
- Ułóż w kolejnościKroki testowania composable
- PytanienextTick w testach
- Kliknij w kolejnościAsercja w teście composable
- Zadanie z kodemPraktyka: Test useSearchFilter
- Ułóż w kolejnościMock funkcji w Vitest