Găzduirea unui API implică responsabilitatea de a se asigura că funcționează. Nu există o modalitate mai bună sau mai ușoară de a face acest lucru decât testarea automată cu un instrument precum Mocha.

Dezvoltarea software modernă folosește foarte mult API-urile. Acestea servesc ca o legătură crucială între aplicațiile de pe partea client și aplicațiile backend, precum și între diferite aplicații interne sau externe.

API-urile permit comunicarea fără probleme și schimbul de date, permițând componentelor software să interacționeze fără probleme între ele. Asigurarea fiabilității, funcționalității și performanței acestor API-uri este de cea mai mare importanță pentru a oferi o experiență de utilizator fără probleme și pentru a menține integritatea generală a sistemului.

Prin urmare, este important să testați temeinic API-urile pentru a semnala și a remedia erorile în timpul dezvoltării pentru a preveni potențialele defecțiuni ale sistemului în mediile de producție.

Testarea API-urilor Node.js folosind Mocha, Chai și Chai-HTTP

instagram viewer

Moca este un cadru de testare utilizat pe scară largă care este compatibil cu diverse cadre JavaScript. Una dintre caracteristicile sale cheie este un test flexibil care simplifică procesul de gestionare și execuție eficientă a cazurilor de testare.

De asemenea, acceptă diverse stiluri de testare, inclusiv testarea sincronă și asincronă, permițând o gamă largă de scenarii de testare.

Pe de altă parte, Chai și Chai-HTTP sunt biblioteci de afirmații pe care le puteți folosi împreună cu Mocha. Chai oferă o gamă largă de interfețe de afirmare expresive și lizibile, cum ar fi ar trebui, așteptați și afirmă. În timp ce, Chai-HTTP, o extensie a Chai, oferă o interfață special concepută pentru testarea solicitărilor HTTP și afirmarea răspunsurilor acestora.

Folosind Mocha împreună cu Chai și Chai-HTTP, puteți testa eficient API-urile. Fluxul de lucru de testare implică:

  • Efectuarea de solicitări HTTP către punctele finale API specificate.
  • Definirea răspunsurilor așteptate.
  • Validarea datelor primite de la sursa specificată, codurile de stare HTTP și multe altele.

De asemenea, puteți simula scenarii de testare a erorilor API care pot apărea în astfel de situații și ce acțiuni ar trebui să declanșeze în cazul în care acestea apar.

Puteți găsi codul acestui proiect în documentul său Depozitul GitHub.

Configurați proiectul Express.js și baza de date MongoDB

Pentru a incepe, creați un server web Expressși instalați aceste pachete:

npm instalează cors dotenv mongoose mongodb

Următorul, creați o bază de date MongoDB sau configurați un cluster MongoDB pe cloud. Apoi copiați adresa URL a conexiunii la baza de date, creați un .env fișier în directorul rădăcină și inserați în șirul de conexiune la baza de date:

CONNECTION_STRING="șir de conexiune"

Pentru a finaliza procesul de configurare, trebuie să configurați conexiunea la baza de date și să definiți modelele de date pentru datele dvs. de utilizator. Consultați codul din depozitul GitHub al acestui proiect pentru a:

  • Configurați conexiunea la baza de date, în utils/db.js.
  • Definiți schema datelor utilizator în modele/user.model.js.

Definiți funcțiile de gestionare pentru rutele API

Funcțiile controlerului vor gestiona adăugarea și preluarea datelor utilizatorului în baza de date. Pentru a asigura funcționalitatea acestor funcții de gestionare, veți testa dacă pot posta și prelua cu succes date din baza de date.

În directorul rădăcină, creați un controllers/userControllers.js fișier și adăugați următorul cod:

const Utilizator = cere(„../models/user.model”);
exports.registerUser = asincron (req, res) => {
const { nume de utilizator, parolă } = req.body;


încerca {
asteapta User.create({ nume de utilizator, parolă});
 starea res.(201).trimite({ mesaj: „Utilizatorul s-a înregistrat cu succes” });
 } captură (eroare) {
consolă.log (eroare);
 starea res.(500).trimite({ mesaj: 'A aparut o eroare!! ' });
 }
};
exports.getUsers = asincron (req, res) => {
încerca {
const utilizatori = asteapta User.find({});
 res.json (utilizatori);
 } captură (eroare) {
consolă.log (eroare);
 starea res.(500).trimite({ mesaj: 'A aparut o eroare!!' });
 }
};

Definiți rutele API

Creaza un nou routes/userRoutes.js fișier în directorul rădăcină și adăugați următorul cod.

const expres = cere('expres');
const router = expres. Router();
const userControllers = cere(„../controllers/userControllers”);
router.post(„/api/register”, userControllers.registerUser);
router.get(„/api/users”, userControllers.getUsers);
modul.exports = router;

Definiți punctul dvs. de intrare în server

Actualizați-vă server.js fișier cu următorul cod.

const expres = cere('expres');
const cors = cere('cors');
const aplicație = expres();
const port = 5000;
cere('dotenv').config();
const connectDB = cere(„./utils/db”);
connectDB();


app.use (express.json());
app.use (express.urlencoded({ extins: Adevărat }));
app.use (cors());


const userRoutes = cere(„./routes/userRoutes”);
app.use('/', userRoutes);


app.listen (port, () => {
consolă.Buturuga(`Serverul ascultă la http://localhost:${port}`);
});
modul.exports = aplicație;

Scrieți și executați cazurile de testare cu Mocha

Cu API-ul utilizatorului, continuați și configurați mediul de testare. Mai întâi, instalați aceste pachete ca dependențe de dezvoltare.

npm instalează mocha chai chai-http --save-dev

Acum, adăugați următorul script în fișierul package.json.

"scripte": {
"Test": "mocha --timeout 10000"
},

Această comandă va executa cazurile de testare — adăugarea proprietății timeout cu o valoare adecvată vă permite să controlați timpul maxim permis pentru executarea cazurilor de testare individuale.

Acest lucru poate fi util pentru a preveni rularea testelor pe termen nelimitat sau finalizarea prea rapidă înainte ca cazurile de testare să se termine.

Testați punctele finale API

În directorul rădăcină, creați un folder nou și denumiți-l Test. În interiorul acestui folder, creați unul nou user.tests.js fișier și adăugați următorul cod pentru cazul de testare a punctului final POST.

const chai = cere('chai');
const chaiHttp = cere(„chai-http”);
const aplicație = cere('../Server'); 
chai.use (chaiHttp);
const expect = chai.expect;


descrie(„User API”, () => {
 descrie(„POST /api/register”, () => {
 aceasta(„ar trebui să se ocupe de înregistrarea utilizatorilor”, (terminat) => {
 chai.request (aplicație)
 .post(„/api/register”)
 .trimite({ nume de utilizator: 'testUser', parola: 'testpassword' })
 .Sfârşit((greș, res) => {
dacă (eroare) {
 așteptați (res).să aibă.statut(500);
 așteaptă (res.corp).să aibă.proprietate('mesaj').care.este.egal('A aparut o eroare!!');
 } altfel {
 așteptați (res).să aibă.statut(201);
 așteaptă (res.corp).să aibă.proprietate('mesaj').egal(„Utilizatorul s-a înregistrat cu succes”);
 }
 Terminat();
 });
 });
 });
});

Acest cod definește un caz de testare folosind Chai și Chai HTTP pentru a testa funcționalitatea de înregistrare a utilizatorului a API-ului utilizator.

Trimite o solicitare POST la punctul final specificat și face afirmații despre răspunsul API așteptat, verificând dacă funcționalitatea de înregistrare a utilizatorului a avut succes sau dacă a apărut o eroare.

Iată o defalcare a principalelor componente ale cazului de testare:

  • aştepta -Acest obiect vă permite să utilizați metodele de afirmare Chai pentru a face afirmații despre răspunsul așteptat de la API.
  • descrie - Descrie cazuri de testare conexe împreună, în acest caz, teste legate de API-ul utilizatorului. Blocul descris imbricat grupează mai departe cazurile de testare legate împreună, în acest caz, POST /api/register. Acest lucru ajută la organizarea cazurilor de testare legate în mod specific de o anumită funcționalitate.
  • aceasta - Această funcție descrie comportamentul așteptat al punctului final API.
  • Sfârşit - Această funcție trimite cererea și oferă o funcție de apel invers pentru a gestiona răspunsul. Funcția de apel invers efectuează afirmații folosind aştepta funcția de verificare a răspunsului primit de la API.
  • Terminat - Această funcție rulează pentru a marca sfârșitul cazului de testare.

În cele din urmă, adăugați codul pentru cazul de testare a punctului final GET imediat după cazul de testare a punctului final POST.

descrie(„GET /api/users”, () => {
 aceasta(„ar trebui să preia toate datele utilizatorului”, (terminat) => {
 chai.request (aplicație)
 .obține(„/api/users”)
 .Sfârşit((greș, res) => {
dacă (eroare) {
 așteptați (res).să aibă.statut(500);
 așteaptă (res.corp).să aibă.proprietate('mesaj').care.este.egal(„A apărut o eroare la preluarea datelor utilizatorului”);
 } altfel {
 așteptați (res).să aibă.statut(200);
 așteptați (res.body).să fie.un(„matrice”);
 }
 Terminat();
 });
 });
});

Continuați și rulați scriptul de testare pe terminalul dvs. pentru a executa cele două cazuri de testare.

testul npm

Dacă execuția cazurilor de testare nu întâmpină erori, ar trebui să vedeți rezultate similare care indică faptul că testele au trecut cu succes.

Eșecurile testelor pot apărea din diverse motive, cum ar fi probleme de conectivitate la rețea în timpul solicitărilor HTTP către baza de date, lipsa datelor necesare, erori logice și alte probleme.

Mocha face o treabă bună în identificarea și evidențierea unor astfel de erori, oferind rapoarte de testare clare și detaliate în jurnalele afișate în fereastra terminalului. Acest lucru vă permite să identificați și să diagnosticați cu ușurință problemele specifice care au cauzat eșecurile testului.

Mocha nu vă oferă nicio scuză să nu vă testați API-urile

În timp ce testarea manuală a funcționalității API-urilor dvs. folosind instrumente precum Postman este o testare validă abordare, valorificând Mocha și alte cadre de testare pentru testarea automată duce la următoarea nivel.

Cu aceste instrumente de testare, puteți automatiza rapid și ușor testele pentru a acoperi o gamă largă de scenarii și cazuri marginale. Acest lucru vă permite să detectați rapid erorile și să le rezolvați înainte de a vă implementa API-urile, asigurându-vă că livrați software de înaltă calitate la producție.