Čeprav je testiranje lahko dolgotrajno, je pomemben korak v razvojnem ciklu vsake aplikacije. Zagotavlja, da zgodaj odkrijete napake in težave, preden kodo potisnete v proizvodnjo.

Jest lahko uporabite za testiranje API-ja Express Rest. Ko ustvarite preprost API CRUD, odkrijte, kako napisati teste za vsako končno točko.

Kaj je Jest?

Izbirate lahko med številnimi knjižnicami za testiranje JavaScript, vendar Šala je najlažje začeti. Je knjižnica za testiranje, ki jo je razvil Facebook in se večinoma uporablja za testiranje projektov React. Vendar pa ga lahko uporabite tudi za testiranje Node in drugih projektov, ki temeljijo na JavaScriptu. Razvit je bil poleg Jasmine, drugega orodja za testiranje, in je priložen lastni knjižnici trditev.

Medtem ko za pisanje testov v Jestu ne boste potrebovali knjižnice trditev, boste morali uporabiti orodje za izdelavo zahtev HTTP. Ta članek uporablja SuperTest.

Kaj je SuperTest?

SuperTest je knjižnica za testiranje vozlišča za klice HTTP. Razširja knjižnico za testiranje superagentov in vam omogoča, da postavljate zahteve, kot so GET, POST, PUT in DELETE.

instagram viewer

SuperTest ponuja objekt zahteve, ki ga lahko uporabite za izdelavo zahtev HTTP.

konst zahteva = zahtevati("supertest")
prošnja("https://icanhazdadjoke.com")
.get('/slack')
.end(funkcijo(napaka, res) {
če (napaka) metati napaka;
konzola.log(res.telo.priponke);
});

Tukaj posredujete osnovni URL API-ja objektu zahteve in nato verižite metodo HTTP s preostalim URL-jem. The konec () metoda pokliče strežnik API in funkcija povratnega klica obravnava njegov odgovor.

Ko prejmete odgovor API-ja, ga lahko potrdite z Jestom.

Ustvarite Express API

Če želite preizkusiti lastne končne točke API-ja, morate ustvariti API REST prvi. API, ki ga boste ustvarili, je zelo preprost. Vstavi, pridobi, posodobi in izbriše elemente iz matrike.

Začnite z ustvarjanjem novega imenika z imenom node-jest in inicializacijo npm.

mkdir vozlišče-jest
npm init -y

Nato ustvarite novo datoteko z imenom index.js in ustvarite strežnik Express.

konst izraziti = zahtevati("hitro")
konst app = express()
app.listen (3000, () => console.log("Poslušanje na vratih 3000"))

Preizkusite končno točko GET /todos

Prva končna točka, ki jo boste ustvarili, je končna točka GET /todos. Vrne vse elemente v matriki. V index.js dodajte naslednje.

konst todos = [
];
// Pridobi vsa opravila
app.get("/todos", (req, res) => {
vrnitevres.stanje(200).json({
 podatki: todos,
 napaka: nič,
 });
});

Upoštevajte, da ima odgovor statusno kodo 200 in objekt JSON, ki vsebuje element opravil v matriki, imenovani podatki, in sporočilo o napaki. To boste preizkusili z uporabo Jesta.

Zdaj namestite Jest in SuperTest:

npm namestite jest supertest

Nato dodajte testni skript package.json kot sledi:

{
"skripte": {
"test": "šala"
 }
}

Preden začnete pisati lastne teste, morate razumeti, kako napisati osnovni test v Jestu.

Razmislite o naslednji funkciji:

funkcijovsota(a, b) {
vrnitev a + b;
}
modul.izvoz = vsota;

V testni datoteki morate:

  • Uvozite funkcijo.
  • Opišite, kaj mora narediti test.
  • Pokličite funkcijo.
  • Uveljavite pričakovani odziv z dejanskim odzivom funkcije. 
konst {vsota} = zahtevati("./vsota")
opisati ("Vsota dveh postavk", async() => {
 test("Vrniti bi se moralo 4", () => {
pričakovati(vsota(2,2)).biti(4)
 })
})

The opisati ključna beseda določa skupino testov in test izjava določa določen test. Če se vrednost, vrnjena iz funkcije, ujema s posredovano vrednostjo biti, test uspešno.

Ko preskušate končne točke API-ja, ne boste klicali funkcije, ampak poslali zahtevo z uporabo SuperTest ali druge odjemalske knjižnice HTTP.

Če se vrnete na končno točko GET, ustvarite novo datoteko, imenovano api.test.js. Tukaj boste napisali vse teste končne točke. Poimenovanje testne datoteke z a .test infix zagotavlja, da jo Jest prepozna kot testno datoteko.

V api.test.js uvozite supertest in nastavite osnovni URL tako:

konst zahteva = zahtevati("supertest")
konst baseURL = "http://lokalni gostitelj: 3000"

Nato ustvarite prvi test v bloku opisa:

opisati ("GET /todos", () => {
konst newTodo = {
id: kripto.naključniUUID(),
 predmet: "Piti vodo",
 dokončano: lažno,
 }
 pred Vsem(asinh () => {
// nastavi opravilo
 čakaj na zahtevo (baseURL).post("/todo").send (novoOpravilo);
 })
 konec koncev(asinh () => {
čakati zahteva (baseURL).delete(`/todo/${newTodo.id}`)
 })
 to("mora vrniti 200", async () => {
konst odgovor = čakati zahteva (baseURL).get("/todos");
pričakovati(odgovor.statusCode).biti(200);
pričakovati(odgovor.telo.napaka).biti(nič);
 });
 to("mora vrniti todos", async () => {
konst odgovor = čakati zahteva (baseURL).get("/todos");
 pričakuj (response.body.data.length >= 1).biti(prav);
 });
});

Pred izvajanjem preizkusov boste morali definirati nastavitvene in razgradne funkcije. Te funkcije bodo napolnile matriko opravil z elementom pred preizkusom in izbrisale navidezne podatke po vsakem preizkusu.

Koda, ki se izvaja pred vsemi testi, je v funkciji beforeAll(). Koda, ki se izvaja po vseh testih, je v funkciji afterAll().

V tem primeru preprosto dosežete končni točki POST in DELETE za vsako. V resnični aplikaciji bi se verjetno povezali z lažno bazo podatkov, ki vsebuje testne podatke.

V tem preizkusu ste najprej podali zahtevo končni točki GET /todos in primerjali poslani odgovor s pričakovanimi rezultati. Ta paket testov bo uspel, če ima odgovor Statusna koda HTTP od 200, podatki niso prazni in sporočilo o napaki je ničelno.

Preizkusite končno točko POST /todo

V index.js ustvarite končno točko POST /todo:

app.post("/todo", (req, res) => {
poskusi {
konst { id, item, completed } = req.body;
konst newTodo = {
 id,
 predmet,
 dokončano,
 };
todos.potisni(novoTodo);
vrnitevres.stanje(201).json({
 podatki: todos,
 napaka: nič,
 });
 } ulov (napaka) {
vrnitevres.stanje(500).json({
 podatki: nič,
 napaka: napaka,
 });
 }
});

V tem preizkusu boste morali poslati podrobnosti opravil v telesu zahteve z metodo send().

zahteva (baseURL).post("/todo").send (novo opravilo)

Zahteva POST /todo mora vrniti statusno kodo 201 in matriko opravil z novim elementom, dodanim na koncu. Takole bi lahko izgledal test:

opisati ("OBJAVA /todo", () => {
konst newTodo = {
// narediti 
 }
 konec koncev(asinh () => {
čakati zahteva (baseURL).delete(`/todo/${newTodo.id}`)
 })
 to("mora dodati element v matriko opravil", async () => {
konst odgovor = čakati zahteva (baseURL).post("/todo").send(newTodo);
konst lastItem = response.body.data[response.body.data.length-1]
pričakovati(odgovor.statusCode).biti(201);
pričakovati(zadnjipredmet.predmet).biti(novoTodo["predmet"]);
pričakovati(zadnjipredmet.dokončano).biti(novoTodo["končano"]);
 });
});

Tukaj kot argument posredujete podatke o opravilih metodi send(). Odgovor mora imeti statusno kodo 201 in vsebovati tudi vse elemente opravil v podatkovnem objektu. Če želite preveriti, ali je bilo opravilo dejansko ustvarjeno, preverite, ali se zadnji vnos v vrnjenih opravilih ujema s tistim, ki ste ga poslali v zahtevi.

Končna točka PUT /todos/:id mora vrniti posodobljen element:

app.put("/todos/:id", (req, res) => {
poskusi {
konst id = req.params.id
konst todo = todos.find((todo) => todo.id == id);
 if(!todo) {
metatinovoNapaka("Todo ni bilo najdeno")
 }
 todo.completed = req.body.completed;
vrnitevres.stanje(201).json({
 podatki: opravila,
 napaka: nič,
 });
 } ulov (napaka) {
vrnitevres.stanje(500).json({
 podatki: nič,
 napaka: napaka,
 });
 }
});

Preizkusite odziv na naslednji način:

opisati ("Posodobite eno opravilo", () => {
konst newTodo = {
// narediti 
 }
 pred Vsem(asinh () => {
 čakaj na zahtevo (baseURL).post("/todo").send (novoOpravilo);
 })
 konec koncev(asinh () => {
čakati zahteva (baseURL).delete(`/todo/${newTodo.id}`)
 })
 to("naj posodobi predmet, če obstaja", async () => {
konst odgovor = čakati zahteva (baseURL).put(`/todos/${newTodo.id}`).pošlji({
 dokončano: prav,
 });
pričakovati(odgovor.statusCode).biti(201);
pričakovati(odgovor.telo.podatki.dokončano).biti(prav);
 });
});

Izpolnjena vrednost v telesu odgovora mora biti resnična. V URL ne pozabite vključiti ID-ja elementa, ki ga želite posodobiti.

Preizkusite končno točko DELETE /todos/:id

V index.js ustvarite končno točko DELETE. Podatke o opravilih mora vrniti brez izbrisanega elementa.

app.delete("/todos/:id", (req, res) => {
poskusi { 
konst id = req.params.id
konst todo = todos[0]
 if (todo) {
todos.splice(id, 1)
 }
vrnitevres.stanje(200).json({
 podatki: todos,
 napaka: nič,
 });
 } ulov (napaka) {
vrnitevres.stanje(500).json({
 podatki: nič,
 napaka: napaka,
 });
 }
});

Če želite preizkusiti končno točko, lahko preverite, ali izbrisani element še vedno obstaja v vrnjenih podatkih:

opisati ("Izbriši eno opravilo", () => {
konst newTodo = {
// narediti
 }
 pred Vsem(asinh () => {
 čakaj na zahtevo (baseURL).post("/todo").send (novoOpravilo);
 })
 to("mora izbrisati en predmet", async () => {
konst odgovor = čakati zahteva (baseURL).delete(`/todos/${newTodo.id}`);
konst todos = response.body.data
konst obstaja = todos.find (todo => {
 newTodo.id == todoId
 })
 pričakujem (obstaja).toBe(nedoločeno)
 });
});

Podatki, ki jih vrne končna točka DELETE, ne smejo vsebovati izbrisanega elementa. Ker so vrnjeni elementi v matriki, lahko uporabite Array[id], da preverite, ali je API pravilno izbrisal element. Rezultat bi moral biti napačen.

Ustvarjanje REST API-jev

V tem članku ste se naučili, kako preizkusiti API Express Rest z API-jem Jest. Napisali ste teste za zahteve HTTP GET, PUT, POST in DELETE ter videli, kako poslati podatke do končne točke v URL-ju in zahtevi. To znanje bi morali znati uporabiti pri testiranju lastnega API-ja Rest.