Testowanie API w Playwright

Testowanie API jest kluczowym elementem zapewnienia jakości oprogramowania, umożliwiającym sprawdzenie poprawności działania interfejsów komunikacyjnych między systemami. API to warstwa pośrednicząca między aplikacjami, umożliwiająca wymianę danych i realizację operacji. Playwright, choć znany głównie jako narzędzie do testowania interfejsów użytkownika, oferuje także bogate możliwości testowania API. Dzięki wbudowanemu modułowi APIRequestContext możemy wykonywać żądania HTTP, sprawdzać odpowiedzi serwera oraz integrować testy API z testami interfejsu użytkownika.

W tym artykule przedstawię, jak efektywnie testować API przy użyciu Playwright, jakie są najlepsze praktyki oraz jak połączyć testowanie API z testami UI. Omówię również sposoby przekazywania różnych typów danych, weryfikacji odpowiedzi oraz optymalizacji testów w celu zapewnienia ich maksymalnej skuteczności.

W kontekście platform low-code, takich jak Ferryt, testowanie API odgrywa ważną rolę. Systemy te często wymagają integracji z wieloma zewnętrznymi usługami, np. bazami danych, systemami płatności czy narzędziami analitycznymi. Automatyzacja testów API pozwala na wykrywanie problemów na wczesnym etapie oraz zapewnia stabilność działania integracji w dynamicznie rozwijającym się środowisku.

Konfiguracja środowiska

Aby rozpocząć testowanie API w Playwright, należy zainstalować pakiet Playwright i skonfigurować środowisko. Można to zrobić za pomocą następującej komendy:

npm install @playwright/test

Następnie możemy utworzyć plik konfiguracyjny, np. playwright.config.js, w którym określimy podstawowe ustawienia testów API:

import { defineConfig } from '@playwright/test';

export default defineConfig({

  use: {

    baseURL: 'https://api.example.com',

  },

});

Dzięki temu nie będziemy musieli podawać pełnej ścieżki URL przy każdym zapytaniu, co ułatwia utrzymanie testów i zmniejsza ich podatność na zmiany. Można również skonfigurować globalne nagłówki czy mechanizmy autoryzacji, co pozwala uniknąć powielania kodu w testach.

Tworzenie testów API w Playwright

Po skonfigurowaniu środowiska możemy rozpocząć pisanie testów API. Playwright udostępnia metodę request.newContext(), która pozwala na wykonywanie żądań HTTP w ramach testów.

Przykładowy test GET

import { test, expect, request } from '@playwright/test';

test('Sprawdzenie statusu API', async ({ request }) => {

  const response = await request.get('/status');

  expect(response.status()).toBe(200);

  expect(await response.json()).toEqual({ status: 'ok' });

});

Tego typu testy są przydatne do monitorowania podstawowej dostępności API oraz jego kluczowych funkcji.

Przykładowy test POST

test(’Tworzenie nowego użytkownika’, async ({ request }) => {

const response = await request.post('/users', {

    data: {

      name: 'Jan Kowalski',

      email: 'jan.kowalski@example.com'

    }

  });

  expect(response.status()).toBe(201);

  const responseBody = await response.json();

  expect(responseBody.id).toBeDefined();

});

Testowanie operacji POST jest istotne dla sprawdzenia, czy API poprawnie obsługuje tworzenie nowych zasobów i czy walidacja danych działa prawidłowo.

Autoryzacja i nagłówki

Wiele API wymaga autoryzacji, np. za pomocą tokenów JWT. W Playwright można dodać nagłówki do każdego żądania:

test('Dostęp do zasobu chronionego', async ({ request }) => {

  const token = 'Bearer example_token';

  const response = await request.get('/protected-resource', {

    headers: {

      Authorization: token

    }

  });

  expect(response.status()).toBe(200);

});

Dzięki obsłudze nagłówków możliwe jest testowanie autoryzowanych zasobów, co pozwala upewnić się, że system poprawnie zarządza dostępem użytkowników.

Weryfikacja danych w odpowiedzi

Testy API często wymagają sprawdzenia zwracanych danych. Możemy to zrobić za pomocą metody expect():

test('Pobranie listy użytkowników', async ({ request }) => {

  const response = await request.get('/users');

  expect(response.status()).toBe(200);

  const users = await response.json();

  expect(users).toBeInstanceOf(Array);

  expect(users.length).toBeGreaterThan(0);

});

Dzięki temu możemy zweryfikować integralność zwracanych danych oraz upewnić się, że API zwraca poprawne odpowiedzi.

Testy negatywne

Ważnym aspektem testowania API jest obsługa błędnych przypadków, np. dostępu bez autoryzacji czy niepoprawnych danych wejściowych.

test('Odmowa dostępu bez tokena', async ({ request }) => {

  const response = await request.get('/protected-resource');

  expect(response.status()).toBe(401);

});

Testy negatywne pomagają wychwycić potencjalne luki w zabezpieczeniach oraz sprawdzić, czy API poprawnie obsługuje błędne żądania.

Integracja testów API z testami UI

Playwright pozwala na łączenie testów API i UI, co umożliwia testowanie pełnych scenariuszy użytkownika.

test('Rejestracja użytkownika i logowanie', async ({ page, request }) => {

  // Rejestracja nowego użytkownika przez API

  const response = await request.post('/users', {

    data: { name: 'Anna Nowak', email: 'anna.nowak@example.com' }

  });

  const user = await response.json();

  // Logowanie w UI

  await page.goto('https://example.com/login');

  await page.fill('#email', 'anna.nowak@example.com');

  await page.fill('#password', 'securepassword');

  await page.click('#login');

  // Sprawdzenie, czy użytkownik został zalogowany

  await expect(page.locator('#welcome-message')).toHaveText(`Witaj, ${user.name}`);

});

Asercje w testach API

Asercje pozwalają na weryfikację wyników testów, zapewniając, że odpowiedzi API są zgodne z oczekiwaniami. Playwright oferuje wiele możliwości asercji, obejmujących status odpowiedzi, nagłówki, strukturę i zawartość JSON, a także czasy odpowiedzi.

Sprawdzanie kodów statusu HTTP

Jednym z podstawowych aspektów testowania API jest weryfikacja kodów statusu HTTP. Playwright umożliwia sprawdzanie, czy zwrócony status jest zgodny z oczekiwanym:

expect(response.status()).toBe(200); // Oczekiwany kod statusu 200 OK

expect(response.status()).toBeGreaterThanOrEqual(200); // Oczekiwany dowolny kod 2xx

expect(response.status()).toBeLessThan(400); // Sprawdzenie, czy odpowiedź nie zawiera błędu

Weryfikacja nagłówków odpowiedzi

Nagłówki HTTP zawierają kluczowe informacje, takie jak format danych czy kontrola dostępu. Możemy je weryfikować w testach API:

expect(response.headers()['content-type']).toContain('application/json'); // Sprawdzenie formatu odpowiedzi

expect(response.headers()).toHaveProperty('content-length'); // Sprawdzenie, czy nagłówek content-length istnieje

Sprawdzanie struktury i zawartości JSON

Testowanie API często polega na weryfikacji zwracanych danych w formacie JSON. Możemy to zrobić, sprawdzając obecność określonych kluczy i wartości:

const responseBody = await response.json();

expect(responseBody).toMatchObject({ success: true }); // Sprawdzenie kluczowych wartości

expect(responseBody.items.length).toBeGreaterThan(0); // Sprawdzenie, czy lista elementów nie jest pusta

expect(responseBody.items[0]).toHaveProperty('id'); // Sprawdzenie, czy pierwszy element zawiera klucz 'id'

Asercje dla różnych typów danych

Playwright pozwala na sprawdzanie poprawności różnych typów danych zwracanych przez API:

expect(typeof responseBody.id).toBe('number'); // Sprawdzenie, czy id jest liczbą

expect(Array.isArray(responseBody.items)).toBeTruthy(); // Sprawdzenie, czy items to tablica

expect(typeof responseBody.createdAt).toBe('string'); // Sprawdzenie, czy data jest zwracana jako string

Weryfikacja czasów odpowiedzi API

Wydajność API jest kluczowym aspektem jakości oprogramowania. Możemy weryfikować, czy odpowiedzi zwracane są w akceptowalnym czasie:

const startTime = Date.now();

const response = await request.get('/endpoint');

const responseTime = Date.now() - startTime;

expect(responseTime).toBeLessThan(2000); // Oczekiwanie, że odpowiedź będzie poniżej 2 sekund

Dobre praktyki testowania API w Playwright

1. Izolacja testów – każdy test powinien działać niezależnie od innych. Unikaj zależności między testami, aby wyniki były przewidywalne i powtarzalne. Można to osiągnąć poprzez stosowanie oddzielnych danych testowych dla każdego testu oraz resetowanie środowiska testowego przed uruchomieniem kolejnego testu.
2. Testowanie przypadków granicznych – warto testować API na skrajnych wartościach, aby upewnić się, że system działa poprawnie. Obejmuje to m.in. testowanie pustych danych, wyjątkowo dużych wartości, danych o nietypowym formacie oraz błędnych żądań.
3. Mockowanie odpowiedzi – w przypadku testów, które nie wymagają rzeczywistego połączenia z serwerem, warto stosować mocki. Mockowanie pozwala na uniezależnienie testów od rzeczywistego API, co jest szczególnie przydatne w przypadku niestabilnych środowisk testowych lub w sytuacjach, gdy API jest jeszcze w fazie rozwoju.
4. Weryfikacja czasów odpowiedzi – sprawdzenie, czy API zwraca odpowiedź w akceptowalnym czasie, pomaga wykryć potencjalne problemy z wydajnością. Można to osiągnąć poprzez mierzenie czasu odpowiedzi i ustalanie progów akceptowalnej wydajności.
5. Raportowanie wyników testów – użycie narzędzi do generowania raportów pozwala na lepszą analizę wyników testów oraz szybsze wykrywanie potencjalnych problemów. Playwright oferuje wbudowane wsparcie dla raportowania, a dodatkowo można zintegrować testy z popularnymi narzędziami do analizy wyników, takimi jak Allure czy ReportPortal.
6. Sprawdzanie zgodności z dokumentacją API – testy powinny odzwierciedlać rzeczywiste oczekiwania opisane w dokumentacji API. Warto regularnie aktualizować testy i porównywać je z dokumentacją, aby uniknąć sytuacji, w której testy przestają być zgodne z rzeczywistością.
7. Automatyczne czyszczenie danych testowych – warto dbać o resetowanie danych testowych przed i po testach, aby uniknąć problemów wynikających z konfliktów danych. Można to zrobić poprzez stosowanie dedykowanych endpointów do resetowania danych lub poprzez wykorzystanie transakcji, które są cofane po zakończeniu testu.
8. Testowanie scenariuszy użytkownika – oprócz testów pojedynczych endpointów warto sprawdzać całe scenariusze użytkownika, np. rejestrację i logowanie, wykonywanie transakcji czy zarządzanie danymi użytkownika. Playwright pozwala na łączenie testów API z testami UI, co umożliwia pełne testowanie ścieżek użytkownika.
9. Obsługa błędów i testowanie negatywne – kluczowe jest sprawdzenie, jak API radzi sobie z błędnymi danymi oraz czy odpowiedzi na błędy są zgodne z oczekiwaniami. Powinno się testować sytuacje takie jak nieautoryzowane żądania, brak wymaganych pól czy próby wykonania operacji na nieistniejących zasobach.
10. Monitorowanie API w środowisku produkcyjnym – testowanie API nie kończy się na środowisku developerskim. Warto wdrożyć mechanizmy monitorowania API w środowisku produkcyjnym, np. poprzez regularne wykonywanie testów zdrowia API oraz analizę logów błędów.

Podsumowanie

Playwright to narzędzie do testowania API, które oferuje nie tylko wsparcie dla testów interfejsów użytkownika, ale również szerokie możliwości w zakresie testowania interfejsów komunikacyjnych (API). Dzięki integracji z testami UI oraz wsparciu dla różnych metod HTTP, autoryzacji i dynamicznych danych, Playwright stanowi solidne narzędzie, które może zaspokoić potrzeby zarówno zespołów QA, jak i developerów.

W kontekście platform low-code, takich jak Ferryt, testowanie API przy użyciu Playwright jest szczególnie istotne. Platformy low-code umożliwiają szybkie tworzenie aplikacji bez potrzeby pisania dużej ilości kodu, ale jednocześnie wprowadzają wyzwania związane z integracją z zewnętrznymi usługami, bazami danych, czy narzędziami analitycznymi. Automatyzacja testów API w takim środowisku pozwala na wczesne wykrywanie problemów z integracjami, gwarantując, że aplikacje wytwarzane na platformach low-code będą działały niezawodnie i efektywnie. Playwright wspiera te procesy, oferując elastyczność w testowaniu zarówno API, jak i interfejsu użytkownika, umożliwiając pełne testowanie aplikacji w sposób szybki i kompleksowy.

Zastosowanie dobrych praktyk testowania API w połączeniu z platformami low-code pozwala na zapewnienie wysokiej jakości oprogramowania i niezawodności aplikacji. Regularne testy, monitorowanie API oraz kontrola wydajności i bezpieczeństwa stają się kluczowe w dynamicznych środowiskach, gdzie integracje z zewnętrznymi usługami są fundamentem całego ekosystemu aplikacji. Playwright umożliwia testerom łatwą i efektywną automatyzację tych procesów, dzięki czemu testowanie API w kontekście platform low-code staje się nie tylko prostsze, ale i bardziej niezawodne.