Lai gan testēšana var būt laikietilpīga, tā ir svarīgs solis jebkuras lietojumprogrammas izstrādes ciklā. Tas nodrošina, ka kļūdas un problēmas tiek uztvertas jau agri, pirms koda nosūtīšanas uz ražošanu.

Varat izmantot Jest, lai pārbaudītu Express Rest API. Kad esat izveidojis vienkāršu CRUD API, uzziniet, kā rakstīt testus katram galapunktam.

Kas ir Džests?

Ir daudzas JavaScript testēšanas bibliotēkas, no kurām varat izvēlēties, taču Joks ar to ir visvieglāk sākt. Tā ir Facebook izstrādāta testēšanas bibliotēka, ko galvenokārt izmanto React projektu testēšanai. Tomēr varat to izmantot arī, lai pārbaudītu Node un citus uz JavaScript balstītus projektus. Tas tika izstrādāts, izmantojot citu testēšanas rīku Jasmine, un tas ir komplektā ar savu apgalvojumu bibliotēku.

Lai gan jums nav nepieciešama apgalvojumu bibliotēka, lai rakstītu testus programmā Jest, jums būs jāizmanto rīks, lai veiktu HTTP pieprasījumus. Šajā rakstā tiek izmantots SuperTest.

Kas ir SuperTest?

SuperTests ir mezglu testēšanas bibliotēka HTTP zvaniem. Tas paplašina superaģentu testēšanas bibliotēku un ļauj veikt tādus pieprasījumus kā GET, POST, PUT un DELETE.

instagram viewer

SuperTest nodrošina pieprasījuma objektu, ko varat izmantot, lai veiktu HTTP pieprasījumus.

konst pieprasījums = pieprasīt("supertest")
pieprasījums ("https://icanhazdadjoke.com")
.gūt('/slack')
.end(funkciju(kļūda, res) {
ja (kļūda) mest kļūdīties;
konsole.log(res.body.pielikumi);
});

Šeit jūs nosūtāt API bāzes URL pieprasījuma objektam un pēc tam savienojat HTTP metodi ar pārējo URL. The beigas () metode izsauc API serveri, un atzvanīšanas funkcija apstrādā tā atbildi.

Kad esat saņēmis atbildi no API, varat izmantot Jest, lai to apstiprinātu.

Izveidojiet Express API

Lai pārbaudītu savus API galapunktus, jums ir jāizveido REST API vispirms. API, ko izveidosit, ir pavisam vienkārša. Tas ievieto, izgūst, atjaunina un dzēš vienumus no masīva.

Sāciet, izveidojot jaunu direktoriju ar nosaukumu node-jest un inicializējot npm.

mkdir node-jest
npm init -y

Pēc tam izveidojiet jaunu failu ar nosaukumu index.js un izveidot Express serveri.

konst izteikt = pieprasīt("izteikt")
konst lietotne = express ()
app.listen (3000, () => console.log("Klausīšanās portā 3000"))

Pārbaudiet GET /todos galapunktu

Pirmais galapunkts, ko izveidosit, ir galapunkts GET /todos. Tas atgriež visus masīva vienumus. Programmā index.js pievienojiet tālāk norādīto.

konst todos = [
];
// Saņemt visus uzdevumus
app.get("/todos", (req, res) => {
atgrieztiesres.statuss(200).json({
 dati: todos,
 kļūda: null,
 });
});

Ņemiet vērā, ka atbildes statusa kods ir 200 un JSON objekts, kas satur uzdevumu vienumu masīvā, ko sauc par datiem, un kļūdas ziņojumu. Tas ir tas, ko jūs pārbaudīsit, izmantojot Jest.

Tagad instalējiet Jest un SuperTest:

npm uzstādīt joks supertests

Pēc tam pievienojiet testa skriptu pack.json sekojoši:

{
"skripti": {
"pārbaude": "joks"
 }
}

Pirms sākat rakstīt savus testus, jums vajadzētu saprast, kā Jest uzrakstīt pamata testu.

Apsveriet šādu funkciju:

funkcijusumma(a, b) {
atgriezties a + b;
}
modulis.eksportu = summa;

Pārbaudes failā jums ir nepieciešams:

  • Importējiet funkciju.
  • Aprakstiet, kas testam jādara.
  • Izsauciet funkciju.
  • Apstipriniet gaidīto atbildi ar faktisko atbildes reakciju no funkcijas. 
konst {summa} = pieprasīt(./summa")
aprakstīt ("Divu vienumu summa", async() => {
 pārbaude("Tam vajadzētu atgriezties 4", () => {
gaidīt(summa(2,2)).būt(4)
 })
})

The aprakstīt atslēgvārds norāda testu grupu un pārbaude paziņojums norāda konkrēto testu. Ja no funkcijas atgrieztā vērtība atbilst vērtībai, kas nosūtīta uz būt, tests izturēts.

Pārbaudot API galapunktus, jūs neizsauksit funkciju, bet gan nosūtīsit pieprasījumu, izmantojot SuperTest vai citu HTTP klienta bibliotēku.

Atgriežoties pie GET galapunkta, izveidojiet jaunu failu ar nosaukumu api.test.js. Šeit jūs rakstīsit visus parametru testus. Pārbaudes faila nosaukšana ar a .pārbaude infix nodrošina, ka Jest to atpazīst kā testa failu.

Vietnē api.test.js importējiet supertest un iestatiet pamata URL šādi:

konst pieprasījums = pieprasīt("supertest")
konst baseURL = "http://localhost: 3000"

Pēc tam izveidojiet pirmo testu apraksta blokā:

aprakstīt ("GET /todos", () => {
konst newTodo = {
id: kriptovalūta.randomUUID(),
 lieta: "Dzert ūdeni",
 pabeigts: viltus,
 }
 pirms visiem(asinhrons () => {
// iestatiet uzdevumu
 gaidīt pieprasījumu (baseURL).post("/todo").nosūtīt (newTodo);
 })
 galu galā(asinhrons () => {
gaidīt pieprasījums (baseURL).delete(`/todo/${newTodo.id}`)
 })
 tas ("vajadzētu atdot 200", asinhrons () => {
konst atbilde = gaidīt pieprasījums (baseURL).get("/todos");
gaidīt(atbildi.statusCode).būt(200);
gaidīt(atbildi.body.kļūda).būt(null);
 });
 tas ("vajadzētu atgriezties todos", asinhrons () => {
konst atbilde = gaidīt pieprasījums (baseURL).get("/todos");
 gaidīt (response.body.data.length >= 1).būt(taisnība);
 });
});

Pirms testu palaišanas jums būs jādefinē iestatīšanas un nojaukšanas funkcijas. Šīs funkcijas aizpildīs uzdevumu masīvu ar vienumu pirms pārbaudes un izdzēsīs fiktīvos datus pēc katra testa.

Kods, kas tiek palaists pirms visām pārbaudēm, atrodas funkcijā beforeAll (). Kods, kas tiek palaists pēc visām pārbaudēm, atrodas funkcijā afterAll ().

Šajā piemērā jūs vienkārši nospiežat POST un DELETE galapunktus katram. Reālā lietojumprogrammā jūs, iespējams, izveidotu savienojumu ar viltus datu bāzi, kurā ir testa dati.

Šajā testā jūs vispirms iesniedzāt pieprasījumu galapunktam GET /todos un salīdzinājāt nosūtīto atbildi ar gaidītajiem rezultātiem. Šis testu komplekts tiks izturēts, ja atbildē ir HTTP statusa kods no 200, dati nav tukši, un kļūdas ziņojums ir nulle.

Pārbaudiet POST /todo galapunktu

Programmā index.js izveidojiet POST /todo galapunktu:

app.post("/todo", (req, res) => {
mēģināt {
konst { id, vienums, pabeigts } = req.body;
konst newTodo = {
 id,
 lieta,
 pabeigts,
 };
todos.spiediet(jaunsTodo);
atgrieztiesres.statuss(201).json({
 dati: todos,
 kļūda: null,
 });
 } noķert (kļūda) {
atgrieztiesres.statuss(500).json({
 dati: null,
 kļūda: kļūda,
 });
 }
});

Šajā testā jums būs jānosūta informācija par uzdevumu pieprasījuma pamattekstā, izmantojot metodi send().

pieprasījums (baseURL).post("/todo").send (newTodo)

POST /todo pieprasījumam ir jāatgriež statusa kods 201 un todos masīvs ar jauno vienumu, kas pievienots beigās. Lūk, kā tests varētu izskatīties:

aprakstīt ("POST /todo", () => {
konst newTodo = {
// darīt 
 }
 galu galā(asinhrons () => {
gaidīt pieprasījums (baseURL).delete(`/todo/${newTodo.id}`)
 })
 tas ("jāpievieno vienums todos masīvam", asinhrons () => {
konst atbilde = gaidīt pieprasījums (baseURL).post("/todo").send(newTodo);
konst lastItem = atbilde.body.data[response.body.data.length-1]
gaidīt(atbildi.statusCode).būt(201);
gaidīt(pēdējais vienums.lieta).būt(jaunsTodo["lieta"]);
gaidīt(pēdējais vienums.pabeigts).būt(jaunsTodo["pabeigts"]);
 });
});

Šeit jūs nododat todo datus metodei send() kā argumentu. Atbildei ir jābūt statusa kodam 201, un tajā jāietver arī visi datu objekta uzdevumi. Lai pārbaudītu, vai uzdevums patiešām ir izveidots, pārbaudiet, vai pēdējais atgriezto uzdevumu ieraksts atbilst pieprasījumam nosūtītajam ierakstam.

PUT /todos/:id galapunktam ir jāatgriež atjauninātais vienums:

app.put("/todos/:id", (req, res) => {
mēģināt {
konst id = req.params.id
konst todo = todos.find((todo) => todo.id == id);
 if(!todo) {
mestjaunsKļūda("Todo nav atrasts")
 }
 todo.completed = req.body.completed;
atgrieztiesres.statuss(201).json({
 dati: todo,
 kļūda: null,
 });
 } noķert (kļūda) {
atgrieztiesres.statuss(500).json({
 dati: null,
 kļūda: kļūda,
 });
 }
});

Pārbaudiet atbildi šādi:

aprakstīt ("Atjauniniet vienu uzdevumu", () => {
konst newTodo = {
// darīt 
 }
 pirms visiem(asinhrons () => {
 gaidīt pieprasījumu (baseURL).post("/todo").nosūtīt (newTodo);
 })
 galu galā(asinhrons () => {
gaidīt pieprasījums (baseURL).delete(`/todo/${newTodo.id}`)
 })
 tas ("ir jāatjaunina vienums, ja tāds pastāv", asinhrons () => {
konst atbilde = gaidīt pieprasījums (baseURL).put(`/todos/${newTodo.id}`).send({
 pabeigts: taisnība,
 });
gaidīt(atbildi.statusCode).būt(201);
gaidīt(atbildi.body.dati.pabeigts).būt(taisnība);
 });
});

Aizpildītajai vērtībai atbildes pamattekstā ir jābūt patiesai. Atcerieties vietrādī URL iekļaut tā vienuma ID, kuru vēlaties atjaunināt.

Pārbaudiet galapunktu DELETE /todos/:id

Programmā index.js izveidojiet galapunktu DELETE. Tam vajadzētu atgriezt uzdevumu datus bez izdzēstā vienuma.

app.delete("/todos/:id", (req, res) => {
mēģināt { 
konst id = req.params.id
konst todo = todos[0]
 if (todo) {
todos.savienot(id, 1)
 }
atgrieztiesres.statuss(200).json({
 dati: todos,
 kļūda: null,
 });
 } noķert (kļūda) {
atgrieztiesres.statuss(500).json({
 dati: null,
 kļūda: kļūda,
 });
 }
});

Lai pārbaudītu galapunktu, varat pārbaudīt, vai dzēstais vienums joprojām pastāv atgrieztajos datos:

aprakstīt ("Dzēst vienu uzdevumu", () => {
konst newTodo = {
// darīt
 }
 pirms visiem(asinhrons () => {
 gaidīt pieprasījumu (baseURL).post("/todo").nosūtīt (newTodo);
 })
 tas ("jāizdzēš viens vienums", asinhrons () => {
konst atbilde = gaidīt pieprasījums (baseURL).delete(`/todos/${newTodo.id}`);
konst todos = atbilde.body.data
konst eksistē = todos.find (todo => {
 newTodo.id == todoId
 })
 gaidīt (pastāv).toBe(nenoteikts)
 });
});

Datos, kas tiek atgriezti no galapunkta DELETE, nevajadzētu ietvert dzēsto vienumu. Tā kā atgrieztie vienumi atrodas masīvā, varat izmantot Array[id], lai pārbaudītu, vai API pareizi izdzēsa vienumu. Rezultātam jābūt nepatiesam.

REST API izveide

Šajā rakstā jūs uzzinājāt, kā pārbaudīt Express Rest API, izmantojot Jest API. Jūs uzrakstījāt testus GET, PUT, POST un DELETE HTTP pieprasījumiem un redzējāt, kā URL un pieprasījumā nosūtīt datus galapunktam. Jums vajadzētu būt iespējai izmantot šīs zināšanas, testējot savu Rest API.