Testarea, deși poate consuma mult timp, este un pas important în ciclul de dezvoltare al oricărei aplicații. Vă asigură că detectați erori și probleme din timp înainte de a împinge codul în producție.

Puteți folosi Jest pentru a testa un API Express Rest. După ce ați creat un API CRUD simplu, descoperiți cum să scrieți teste pentru fiecare punct final.

Ce este gluma?

Există multe biblioteci de testare JavaScript din care puteți alege, dar Glumă este cel mai ușor de început. Este o bibliotecă de testare dezvoltată de Facebook, folosită în principal pentru a testa proiectele React. Cu toate acestea, îl puteți folosi și pentru a testa Node și alte proiecte bazate pe JavaScript. A fost dezvoltat pe lângă Jasmine, un alt instrument de testare, și vine la pachet cu propria bibliotecă de afirmații.

Deși nu veți avea nevoie de o bibliotecă de afirmații pentru a scrie teste în Jest, va trebui să utilizați un instrument pentru a face solicitări HTTP. Acest articol folosește SuperTest.

Ce este SuperTest?

instagram viewer

SuperTest este o bibliotecă de testare Node pentru apeluri HTTP. Acesta extinde biblioteca de testare a superagentului și vă permite să faceți solicitări precum GET, POST, PUT și DELETE.

SuperTest oferă un obiect de solicitare pe care îl puteți utiliza pentru a face solicitări HTTP.

const cerere = cere("supertest")
cerere("https://icanhazdadjoke.com")
.obține('/slack')
.Sfârşit(funcţie(greș, res) {
dacă (eroare) arunca a greșit;
consolă.Buturuga(res.corp.atasamente);
});

Aici, treceți adresa URL de bază a API-ului obiectului de solicitare și apoi conectați metoda HTTP cu restul adresei URL. The Sfârşit() metoda apelează serverul API și funcția de apel invers se ocupă de răspunsul acestuia.

Odată ce primiți răspunsul de la API, puteți utiliza Jest pentru a-l valida.

Creați un API Express

Pentru a testa propriile puncte finale API, trebuie să creați un API REST primul. API-ul pe care îl veți crea este destul de simplu. Inserează, preia, actualizează și șterge articole dintr-o matrice.

Începeți prin crearea unui nou director numit node-jest și inițializarea npm.

mkdir nod-jest
npm init -y

Apoi, creați un fișier nou numit index.js și creați serverul Express.

const expres = cere("expres")
const aplicație = expres()
app.ascultă (3000, () => console.log("Ascult la portul 3000"))

Testați punctul final GET /todos

Primul punct final pe care îl veți crea este punctul final GET /todos. Returnează toate elementele din matrice. În index.js, adăugați următoarele.

const toți = [
];
// Obțineți toate toate
app.get("/todos", (req, res) => {
întoarcereres.stare(200).json({
 date: toate,
 eroare: nul,
 });
});

Rețineți că răspunsul are un cod de stare de 200 și un obiect JSON care conține elementul de făcut într-o matrice numită date și un mesaj de eroare. Acesta este ceea ce veți testa folosind Jest.

Acum, instalați Jest și SuperTest:

npm instalare gluma supertest

Apoi, adăugați un script de testare pachet.json după cum urmează:

{
"scenarii": {
"Test": "glumă"
 }
}

Înainte de a începe să vă scrieți propriile teste, ar trebui să înțelegeți cum să scrieți un test de bază în Jest.

Luați în considerare următoarea funcție:

funcţiesumă(a, b) {
întoarcere a + b;
}
modul.exporturi = suma;

În fișierul de testare, trebuie să:

  • Importă funcția.
  • Descrieți ce ar trebui să facă testul.
  • Apelați funcția.
  • Afirmați răspunsul așteptat cu răspunsul real din funcție. 
const { suma } = cere("./sumă")
descrie("Suma a două articole", asincron() => {
 Test("Ar trebui să revină 4", () => {
aştepta(sumă(2,2)).a fi(4)
 })
})

The descrie cuvântul cheie specifică grupul de teste și Test declarația specifică testul specific. Dacă valoarea returnată de la funcție se potrivește cu valoarea transmisă a fi, testul trece.

Când testați punctele finale API, nu veți apela o funcție, ci veți trimite o solicitare folosind SuperTest sau o altă bibliotecă client HTTP.

Revenind la punctul final GET, creați un nou fișier numit api.test.js. Aici veți scrie toate testele endpoint. Numirea fișierului de testare cu a .Test infix se asigură că Jest îl recunoaște ca fișier de testare.

În api.test.js, importați supertest și setați adresa URL de bază astfel:

const cerere = cere("supertest")
const URL de bază = "http://localhost: 3000"

Apoi, creați primul test în blocul de descriere:

descrie("GET /todos", () => {
const newTodo = {
id: cripto.randomUUID(),
 articol: "Bea apă",
 efectuat: fals,
 }
 inaintea tuturor(asincron () => {
// configurați tot
 așteaptă cererea (baseURL).post("/todo").trimite (nouTodo);
 })
 dupa toate acestea(asincron () => {
așteaptă cerere (baseURL).delete(`/tot/${newTodo.id}`)
 })
 aceasta("ar trebui sa returneze 200", asincron () => {
const răspuns = așteaptă cerere (baseURL).get("/todos");
aştepta(raspuns.statusCode).a fi(200);
aştepta(raspuns.corp.eroare).a fi(nul);
 });
 aceasta("ar trebui să returneze toate", asincron () => {
const răspuns = așteaptă cerere (baseURL).get("/todos");
 așteptați (response.body.data.length >= 1).a fi(Adevărat);
 });
});

Înainte de a rula testele, va trebui să definiți funcțiile de configurare și dezasamblare. Aceste funcții vor popula matricea todo cu un articol înainte de test și vor șterge datele inactiv după fiecare test.

Codul care rulează înainte de toate testele se află în funcția beforeAll(). Codul care rulează după toate testele se află în funcția afterAll().

În acest exemplu, atingeți pur și simplu punctele finale POST și DELETE pentru fiecare. Într-o aplicație reală, probabil că v-ați conecta la o bază de date simulată care conține datele de testare.

În acest test, ați făcut mai întâi o solicitare către punctul final GET /todos și ați comparat răspunsul trimis înapoi cu rezultatele așteptate. Această suită de teste va trece dacă răspunsul are un Cod de stare HTTP de 200, datele nu sunt goale, iar mesajul de eroare este nul.

Testați punctul final POST /todo

În index.js, creați punctul final POST /todo:

app.post("/todo", (req, res) => {
încerca {
const { id, item, completed } = req.body;
const newTodo = {
 id,
 articol,
 efectuat,
 };
toate.Apăsaţi(nouTodo);
întoarcereres.stare(201).json({
 date: toate,
 eroare: nul,
 });
 } captură (eroare) {
întoarcereres.stare(500).json({
 date: nul,
 eroare: eroare,
 });
 }
});

În acest test, va trebui să trimiteți detaliile de tot în corpul cererii folosind metoda send().

cerere (baseURL).post("/todo").trimite (newTodo)

Solicitarea POST /todo ar trebui să returneze un cod de stare 201 și matricea todos cu noul articol adăugat la sfârșit. Iată cum ar putea arăta testul:

descrie("POST /todo", () => {
const newTodo = {
// a face 
 }
 dupa toate acestea(asincron () => {
așteaptă cerere (baseURL).delete(`/tot/${newTodo.id}`)
 })
 aceasta("ar trebui să adauge un element la matricea todos", asincron () => {
const răspuns = așteaptă cerere (baseURL).post("/todo").send(newTodo);
const lastItem = răspuns.corp.datele[răspunsul.corp.datele.lungime-1]
aştepta(raspuns.statusCode).a fi(201);
aştepta(ultimul element.articol).a fi(nouTodo["articol"]);
aştepta(ultimul element.efectuat).a fi(nouTodo["efectuat"]);
 });
});

Aici, treceți datele todo la metoda send() ca argument. Răspunsul ar trebui să aibă un cod de stare 201 și, de asemenea, să conțină toate elementele de tot dintr-un obiect de date. Pentru a testa dacă todo a fost de fapt creat, verificați dacă ultima intrare din toate returnate se potrivește cu cea pe care ați trimis-o în cerere.

Punctul final PUT /todos/:id ar trebui să returneze articolul actualizat:

app.put("/todos/:id", (req, res) => {
încerca {
const id = req.params.id
const tot = todos.find((todo) => todo.id == id);
 if(!todo) {
aruncanouEroare("Todo nu a fost găsit")
 }
 todo.completed = req.body.completed;
întoarcereres.stare(201).json({
 date: tot,
 eroare: nul,
 });
 } captură (eroare) {
întoarcereres.stare(500).json({
 date: nul,
 eroare: eroare,
 });
 }
});

Testați răspunsul după cum urmează:

descrie("Actualizați o problemă", () => {
const newTodo = {
// a face 
 }
 inaintea tuturor(asincron () => {
 așteaptă cererea (baseURL).post("/todo").trimite (nouTodo);
 })
 dupa toate acestea(asincron () => {
așteaptă cerere (baseURL).delete(`/tot/${newTodo.id}`)
 })
 aceasta("ar trebui să actualizeze elementul dacă acesta există", asincron () => {
const răspuns = așteaptă cerere (baseURL).put(`/todos/${newTodo.id}`).trimite({
 efectuat: Adevărat,
 });
aştepta(raspuns.statusCode).a fi(201);
aştepta(raspuns.corp.date.efectuat).a fi(Adevărat);
 });
});

Valoarea completată în corpul răspunsului ar trebui să fie adevărată. Nu uitați să includeți id-ul articolului pe care doriți să îl actualizați în adresa URL.

Testați DELETE /todos/:id Endpoint-ul

În index.js, creați punctul final DELETE. Ar trebui să returneze toate datele fără elementul șters.

app.delete("/todos/:id", (req, res) => {
încerca { 
const id = req.params.id
const tot = toate[0]
 dacă (tot de făcut) {
toate.lipitură(id, 1)
 }
întoarcereres.stare(200).json({
 date: toate,
 eroare: nul,
 });
 } captură (eroare) {
întoarcereres.stare(500).json({
 date: nul,
 eroare: eroare,
 });
 }
});

Pentru a testa punctul final, puteți verifica dacă elementul șters mai există în datele returnate:

descrie("Ștergeți o problemă", () => {
const newTodo = {
// a face
 }
 inaintea tuturor(asincron () => {
 așteaptă cererea (baseURL).post("/todo").trimite (nouTodo);
 })
 aceasta("ar trebui să șterge un articol", asincron () => {
const răspuns = așteaptă cerere (baseURL).delete(`/todos/${newTodo.id}`);
const todos = response.body.data
const există = todos.find (todo => {
 newTodo.id == todoId
 })
 așteaptă (există).să fie(nedefinit)
 });
});

Datele returnate de la punctul final DELETE nu trebuie să conțină elementul șters. Deoarece articolele returnate sunt într-o matrice, puteți utiliza Array[id] pentru a verifica dacă API-ul a șters corect articolul. Rezultatul ar trebui să fie fals.

Crearea API-urilor REST

În acest articol, ați învățat cum să testați un API Express Rest folosind API-ul Jest. Ați scris teste pentru solicitările HTTP GET, PUT, POST și DELETE și ați văzut cum să trimiteți date către punctul final în adresa URL și în cerere. Ar trebui să puteți aplica aceste cunoștințe atunci când vă testați propriul API Rest.