Hosting interfejsu API wiąże się z odpowiedzialnością za zapewnienie jego działania. Nie ma na to lepszego ani łatwiejszego sposobu niż automatyczne testowanie za pomocą narzędzia takiego jak Mocha.

Nowoczesne tworzenie oprogramowania doskonale wykorzystuje interfejsy API. Służą jako kluczowe ogniwo między aplikacjami po stronie klienta a aplikacjami zaplecza, a także między różnymi aplikacjami wewnętrznymi lub zewnętrznymi.

Interfejsy API umożliwiają płynną komunikację i wymianę danych, umożliwiając bezproblemową interakcję komponentów oprogramowania. Zapewnienie niezawodności, funkcjonalności i wydajności tych interfejsów API ma ogromne znaczenie dla zapewnienia płynnej obsługi użytkownika i utrzymania ogólnej integralności systemu.

Dlatego ważne jest dokładne przetestowanie interfejsów API w celu oznaczania i naprawiania błędów podczas opracowywania, aby zapobiec potencjalnym awariom systemu w środowiskach produkcyjnych.

Testowanie interfejsów API Node.js przy użyciu Mocha, Chai i Chai-HTTP

instagram viewer

Mokka to powszechnie stosowana platforma testowa, która jest kompatybilna z różnymi Frameworki JavaScript. Jedną z jego kluczowych cech jest elastyczny program do uruchamiania testów, który upraszcza proces efektywnego zarządzania i wykonywania przypadków testowych.

Obsługuje również różne style testowania, w tym testy synchroniczne i asynchroniczne, umożliwiając szeroki zakres scenariuszy testowych.

Z drugiej strony, Czaj I Chai-HTTP to biblioteki asercji, których można używać w połączeniu z Mocha. Chai zapewnia szeroką gamę wyrazistych i czytelnych interfejsów asercji, takich jak powinno, oczekiwać i zapewniać. Podczas gdy Chai-HTTP, rozszerzenie Chai, zapewnia interfejs zaprojektowany specjalnie do testowania żądań HTTP i potwierdzania ich odpowiedzi.

Używając Mocha w połączeniu z Chai i Chai-HTTP, możesz skutecznie testować interfejsy API. Przepływ pracy testowej obejmuje:

  • Wykonywanie żądań HTTP do określonych punktów końcowych API.
  • Określenie oczekiwanych odpowiedzi.
  • Sprawdzanie poprawności otrzymanych danych z określonego źródła, kodów stanu HTTP i nie tylko.

Możesz także symulować scenariusze testów błędów API, które mogą wystąpić w takich sytuacjach i jakie działania powinny wywołać w przypadku ich wystąpienia.

Możesz znaleźć kod tego projektu w jego Repozytorium GitHub.

Skonfiguruj projekt Express.js i bazę danych MongoDB

Rozpocząć, utwórz serwer sieciowy Expressi zainstaluj te pakiety:

npm install cors dotenv mongoose mongodb

Następny, utwórz bazę danych MongoDB Lub skonfiguruj klaster MongoDB w chmurze. Następnie skopiuj adres URL połączenia z bazą danych, utwórz plik .env plik w katalogu głównym i wklej parametry połączenia z bazą danych:

CONNECTION_STRING="ciąg połączenia"

Aby zakończyć proces instalacji, musisz skonfigurować połączenie z bazą danych i zdefiniować modele danych dla danych użytkownika. Zapoznaj się z kodem w repozytorium GitHub tego projektu, aby:

  • Skonfiguruj połączenie z bazą danych, w utils/db.js.
  • Zdefiniuj schemat danych użytkownika w modele/użytkownik.model.js.

Zdefiniuj funkcje obsługi dla tras API

Funkcje kontrolera będą zarządzać dodawaniem i pobieraniem danych użytkownika w bazie danych. Aby zapewnić funkcjonalność tych funkcji obsługi, przetestujesz, czy mogą pomyślnie wysyłać i pobierać dane z bazy danych.

W katalogu głównym utwórz plik controllers/userControllers.js plik i dodaj następujący kod:

konst Użytkownik = wymagać(„../modele/model.użytkownika”);
exports.registerUżytkownik = asynchroniczny (wymaganie, res) => {
konst { nazwa użytkownika, hasło } = req.body;


próbować {
czekać na User.create({ nazwa użytkownika, hasło});
 res.status(201).wysłać({ wiadomość: „Użytkownik zarejestrowany pomyślnie” });
 } złapać (błąd) {
konsola.log (błąd);
 res.status(500).wysłać({ wiadomość: 'Wystąpił błąd!! ' });
 }
};
exports.getUsers = asynchroniczny (wymaganie, res) => {
próbować {
konst użytkownicy = czekać na User.find({});
 res.json (użytkownicy);
 } złapać (błąd) {
konsola.log (błąd);
 res.status(500).wysłać({ wiadomość: 'Wystąpił błąd!!' });
 }
};

Zdefiniuj trasy API

Stwórz nowy trasy/użytkownikRoutes.js plik w katalogu głównym i dodaj następujący kod.

konst ekspres = wymagać('wyrazić');
konst router = ekspres. router();
konst kontrolery użytkowników = wymagać(„../kontrolery/kontrolery użytkownika”);
router.post('/api/register', userControllers.registerUser);
router.get('/api/użytkownicy', userControllers.getUsers);
moduł.eksport = router;

Zdefiniuj swój punkt wejścia do serwera

Zaktualizuj swój serwer.js plik z następującym kodem.

konst ekspres = wymagać('wyrazić');
konst kors = wymagać(„kors”);
konst aplikacja = ekspres();
konst port = 5000;
wymagać('dotenv'.config();
konst połączDB = wymagać('./narzędzia/db');
połączDB();


app.use (express.json());
app.use (express.urlencoded({ rozszerzony: PRAWDA }));
app.use (cors());


konst trasy użytkownika = wymagać(„./trasy/trasy użytkownika”);
aplikacja.użyć('/', trasy użytkownika);


app.listen (port, () => {
konsola.dziennik(`Serwer nasłuchuje o godz http://localhost:${port}`);
});
moduł.eksport = aplikacja;

Napisz i wykonaj przypadki testowe za pomocą Mocha

Mając interfejs API użytkownika, skonfiguruj środowisko testowe. Najpierw zainstaluj te pakiety jako zależności dev.

npm zainstaluj mocha chai chai-http --save-dev

Teraz dodaj następujący skrypt do pliku package.json.

„skrypty”: {
"test": "mokka -- limit czasu 10000"
},

To polecenie wykona przypadki testowe — dodanie właściwości timeout z odpowiednią wartością pozwala kontrolować maksymalny czas wykonywania poszczególnych przypadków testowych.

Może to być przydatne do zapobiegania uruchamianiu testów w nieskończoność lub zbyt szybkiemu kończeniu przed zakończeniem przypadków testowych.

Przetestuj punkty końcowe interfejsu API

W katalogu głównym utwórz nowy folder i nadaj mu nazwę test. Wewnątrz tego folderu utwórz nowy user.tests.js plik i Dodaj następujący kod dla przypadku testowego punktu końcowego POST.

konst czaj = wymagać(„czaj”);
konst chaiHttp = wymagać('chai-http');
konst aplikacja = wymagać('../serwer'); 
chai.use (czaiHttp);
konst oczekuj = chai. oczekuj;


opisać(„API użytkownika”, () => {
 opisać(„POST /api/register”, () => {
 To(„powinien obsługiwać rejestrację użytkowników”, (gotowe) => {
 chai.request (aplikacja)
 .post('/api/register')
 .wysłać({ nazwa użytkownika: „użytkownik testowy”, hasło: „hasło testowe” })
 .koniec((chyba, rez) => {
Jeśli (błąd) {
 oczekuj (res).mieć.status(500);
 oczekiwać (res.body).mieć.własność('wiadomość').to.jest.równe('Wystąpił błąd!!');
 } w przeciwnym razie {
 oczekuj (res).mieć.status(201);
 oczekiwać (res.body).mieć.własność('wiadomość').równy(„Użytkownik zarejestrowany pomyślnie”);
 }
 zrobione();
 });
 });
 });
});

Ten kod definiuje przypadek testowy wykorzystujący Chai i Chai HTTP do testowania funkcji rejestracji użytkownika w interfejsie API użytkownika.

Wysyła żądanie POST do określonego punktu końcowego i potwierdza oczekiwaną odpowiedź API, sprawdzając, czy funkcja rejestracji użytkownika powiodła się lub czy wystąpił błąd.

Oto zestawienie głównych elementów przypadku testowego:

  • oczekiwać -Ten obiekt umożliwia użycie metod asercji Chai do tworzenia asercji dotyczących oczekiwanej odpowiedzi z interfejsu API.
  • opisać - Opisuje razem powiązane przypadki testowe, w tym przypadku testy związane z API użytkownika. Zagnieżdżony opis bloków dalej grupuje razem powiązane przypadki testowe, w tym przypadku POST /api/register. Pomaga to zorganizować przypadki testowe konkretnie związane z określoną funkcjonalnością.
  • To — Ta funkcja opisuje oczekiwane zachowanie punktu końcowego interfejsu API.
  • koniec - Ta funkcja wysyła żądanie i zapewnia funkcję wywołania zwrotnego do obsługi odpowiedzi. Funkcja wywołania zwrotnego wykonuje asercje przy użyciu metody oczekiwać funkcja sprawdzająca odpowiedź otrzymaną z API.
  • zrobione - Ta funkcja jest uruchamiana, aby zaznaczyć koniec przypadku testowego.

Na koniec dodaj kod przypadku testowego punktu końcowego GET zaraz po przypadku testowym punktu końcowego POST.

opisać(„POBIERZ /api/użytkowników”, () => {
 To(„powinien pobrać wszystkie dane użytkownika”, (gotowe) => {
 chai.request (aplikacja)
 .Dostawać('/api/użytkownicy')
 .koniec((chyba, rez) => {
Jeśli (błąd) {
 oczekuj (res).mieć.status(500);
 oczekiwać (res.body).mieć.własność('wiadomość').to.jest.równe(„Wystąpił błąd podczas pobierania danych użytkownika”);
 } w przeciwnym razie {
 oczekuj (res).mieć.status(200);
 oczekuj (res.body).być.an('szyk');
 }
 zrobione();
 });
 });
});

Śmiało uruchom skrypt testowy na swoim terminalu, aby wykonać dwa przypadki testowe.

test np

Jeśli wykonanie przypadków testowych nie napotka żadnych błędów, powinieneś zobaczyć podobne dane wyjściowe wskazujące, że testy przeszły pomyślnie.

Błędy testów mogą wystąpić z różnych powodów, takich jak problemy z łącznością sieciową podczas żądań HTTP do bazy danych, brak wymaganych danych, błędy logiczne i inne problemy.

Mocha dobrze identyfikuje i podkreśla takie błędy, dostarczając jasne i szczegółowe raporty z testów w dziennikach wyświetlanych w oknie terminala. Pozwala to łatwo identyfikować i diagnozować określone problemy, które spowodowały niepowodzenia testów.

Mocha nie ma wymówki, aby nie testować interfejsów API

Ręczne testowanie funkcjonalności interfejsów API za pomocą narzędzi takich jak Postman jest prawidłowym testowaniem podejście, wykorzystując Mocha i inne ramy testowe do zautomatyzowanego testowania, przenosi je do następnego poziom.

Dzięki tym narzędziom do testowania można szybko i łatwo zautomatyzować testy obejmujące szeroki zakres scenariuszy i przypadków brzegowych. Umożliwia to szybkie wykrywanie błędów i usuwanie ich przed wdrożeniem interfejsów API, co zapewnia dostarczanie wysokiej jakości oprogramowania do produkcji.