Testimine, kuigi see võib olla aeganõudev, on oluline samm iga rakenduse arendustsüklis. See tagab, et avastate vead ja probleemid varakult, enne kui koodi tootmisse suunate.

Jesti saate kasutada Express Rest API testimiseks. Pärast lihtsa CRUD API loomist avastage, kuidas iga lõpp-punkti jaoks teste kirjutada.

Mis on Jest?

Saate valida paljude JavaScripti testimise teekide hulgast, kuid Naljakas on kõige lihtsam alustada. See on Facebooki välja töötatud testimisteek, mida kasutatakse enamasti Reacti projektide testimiseks. Siiski saate seda kasutada ka Node'i ja muude JavaScripti-põhiste projektide testimiseks. See töötati välja teise testimistööriista Jasmine peal ja on komplektis oma kinnitusteekiga.

Kuigi te ei vaja Jestis testide kirjutamiseks väiteteeki, peate HTTP-päringute tegemiseks kasutama tööriista. See artikkel kasutab SuperTesti.

Mis on SuperTest?

SuperTest on HTTP-kõnede sõlmede testimise teek. See laiendab superagendi testimise teeki ja võimaldab teil teha selliseid taotlusi nagu GET, POST, PUT ja DELETE.

instagram viewer

SuperTest pakub päringuobjekti, mida saate kasutada HTTP-päringute tegemiseks.

konst taotlus = nõuda("supertest")
nõuda ("https://icanhazdadjoke.com")
.get('/slack')
.lõpp(funktsiooni(eks, res) {
kui (viga) viskama eksima;
konsool.log(res.keha.manused);
});

Siin edastate API baas-URL-i päringuobjektile ja seejärel aheldate HTTP-meetodi ülejäänud URL-iga. The lõpp() meetod kutsub API serverit ja tagasihelistamise funktsioon tegeleb selle vastusega.

Kui olete API-lt vastuse saanud, saate selle kinnitamiseks kasutada Jesti.

Looge Express API

Oma API lõpp-punktide testimiseks peate looma REST API esiteks. Loodav API on üsna lihtne. See lisab, toob, värskendab ja kustutab massiivi üksusi.

Alustuseks looge uus kataloog nimega node-jest ja lähtestage npm.

mkdir node-jest
npm init -y

Järgmisena looge uus fail nimega index.js ja luua Express server.

konst väljendada = nõuda("ekspress")
konst rakendus = express()
app.listen (3000, () => console.log("Kuulamine pordis 3000"))

Testige GET /todos lõpp-punkti

Esimene lõpp-punkt, mille loote, on GET /todos lõpp-punkt. See tagastab kõik massiivi üksused. Lisage faili index.js järgmine.

konst todos = [
];
// Hangi kõik ülesanded
app.get("/todos", (req, res) => {
tagasires.status(200).json({
 andmed: todos,
 viga: null,
 });
});

Pange tähele, et vastuse olekukood on 200 ja JSON-objekt, mis sisaldab ülesandeid massiivis, mida nimetatakse andmeteks, ja veateadet. Seda testite Jesti abil.

Nüüd installige Jest ja SuperTest:

npm installida naljakas supertest

Seejärel lisage testskript package.json järgnevalt:

{
"skriptid": {
"katsetada": "nalja"
 }
}

Enne kui hakkate oma teste kirjutama, peaksite mõistma, kuidas Jestis põhitesti kirjutada.

Kaaluge järgmist funktsiooni:

funktsioonisumma(a, b) {
tagasi a + b;
}
moodul.eksporti = summa;

Testfailis peate:

  • Importige funktsioon.
  • Kirjeldage, mida test peaks tegema.
  • Kutsu funktsioon.
  • Kinnitage oodatud vastus koos funktsiooni tegeliku vastusega. 
konst {summa} = nõuda(./summa")
kirjelda ("Kahe eseme summa", async() => {
 test("See peaks tagastama 4", () => {
oodata(summa(2,2)).olla(4)
 })
})

The kirjeldada märksõna määrab testide rühma ja katsetada avaldus määrab konkreetse testi. Kui funktsioonist tagastatud väärtus ühtib väärtusega, mis edastati olla, test läbib.

API lõpp-punktide testimisel ei kutsu te funktsiooni, vaid saadate päringu SuperTesti või mõne muu HTTP klienditeegi abil.

Naastes GET-i lõpp-punkti juurde, looge uus fail nimega api.test.js. Siin kirjutate kõik lõpp-punkti testid. Testfaili nimetamine tähega a .test infix tagab, et Jest tuvastab selle testfailina.

Importige failis api.test.js supertest ja määrake põhi-URL järgmiselt:

konst taotlus = nõuda("supertest")
konst baseURL = "http://localhost: 3000"

Järgmisena loo kirjeldusplokis esimene test:

kirjelda ("GET /todos", () => {
konst newTodo = {
id: krüpto.randomUUID(),
 üksus: "Juua vett",
 lõpetatud: vale,
 }
 ennekõike(asünkr () => {
// ülesande seadistamine
 oota taotlust (baseURL).post("/todo".send (uusTodo);
 })
 Pealegi(asünkr () => {
ootama päring (baseURL).delete(`/todo/${newTodo.id}`)
 })
 see ("peaks tagastama 200", asünkroon () => {
konst vastus = ootama päring (baseURL).get("/todos");
oodata(vastuseks.statusCode).olla(200);
oodata(vastuseks.keha.error).olla(null);
 });
 see ("peaks tagasi tegema", asünkroon () => {
konst vastus = ootama päring (baseURL).get("/todos");
 oodata (response.body.data.length >= 1).olla(tõsi);
 });
});

Enne testide käivitamist peate määratlema häälestus- ja rebimisfunktsioonid. Need funktsioonid täidavad enne testimist ülesandemassiivi elemendiga ja kustutavad näivandmed pärast iga testi.

Kood, mis töötab enne kõiki teste, on funktsioonis beforeAll(). Kood, mis töötab pärast kõiki teste, on funktsioonis afterAll().

Selles näites vajutate lihtsalt mõlema jaoks lõpp-punktile POST ja DELETE. Reaalses rakenduses loote tõenäoliselt ühenduse katseandmeid sisaldava näidisandmebaasiga.

Selles testis esitasite esmalt päringu GET /todos lõpp-punktile ja võrdlesite saadetud vastust oodatud tulemustega. See testkomplekt läbib, kui vastusel on HTTP olekukood 200-st ei ole andmed tühjad ja veateade on tühi.

Testige POST /todo lõpp-punkti

Looge failis index.js POST /todo lõpp-punkt:

app.post("/todo", (req, res) => {
proovi {
konst { id, item, complete } = req.body;
konst newTodo = {
 id,
 ese,
 lõpetatud,
 };
todos.push(uusTodo);
tagasires.status(201).json({
 andmed: todos,
 viga: null,
 });
 } püüda (viga) {
tagasires.status(500).json({
 andmed: null,
 viga: viga,
 });
 }
});

Selles testis peate saatma ülesande üksikasjad päringu kehasse, kasutades meetodit send().

päring (baseURL).post("/todo").send (uusTodo)

POST /todo päring peaks tagastama olekukoodi 201 ja massiivi todos, mille lõppu on lisatud uus üksus. Siin võib test välja näha:

kirjelda ("POSTITA /todo", () => {
konst newTodo = {
// tegema 
 }
 Pealegi(asünkr () => {
ootama päring (baseURL).delete(`/todo/${newTodo.id}`)
 })
 see ("peaks lisama üksuse todos massiivi", asünkroon () => {
konst vastus = ootama päring (baseURL).post("/todo").send(newTodo);
konst lastItem = vastus.keha.andmed[vastus.keha.andmed.pikkus-1]
oodata(vastuseks.statusCode).olla(201);
oodata(viimane üksus.element).olla(uusTodo["üksus"]);
oodata(viimane üksus.lõpetatud).olla(uusTodo["lõpetatud"]);
 });
});

Siin edastate ülesande andmed argumendina meetodile send(). Vastusel peaks olema olekukood 201 ja see peaks sisaldama ka kõiki andmeobjekti ülesandeid. Testimaks, kas ülesanded on tegelikult loodud, kontrollige, kas tagastatud ülesannete viimane kirje ühtib päringus saadetud kirjega.

PUT /todos/:id lõpp-punkt peaks tagastama värskendatud üksuse:

app.put("/todos/:id", (req, res) => {
proovi {
konst id = req.params.id
konst todo = todos.find((todo) => todo.id == id);
 if(!todo) {
viskamauusViga("Todot ei leitud")
 }
 todo.completed = req.body.completed;
tagasires.status(201).json({
 andmed: todo,
 viga: null,
 });
 } püüda (viga) {
tagasires.status(500).json({
 andmed: null,
 viga: viga,
 });
 }
});

Testige vastust järgmiselt:

kirjelda ("Värskendage ühte ülesannet", () => {
konst newTodo = {
// tegema 
 }
 ennekõike(asünkr () => {
 oota taotlust (baseURL).post("/todo".send (uusTodo);
 })
 Pealegi(asünkr () => {
ootama päring (baseURL).delete(`/todo/${newTodo.id}`)
 })
 see ("peaks üksust värskendama, kui see on olemas", asünkroon () => {
konst vastus = ootama päring (baseURL).put(`/todos/${newTodo.id}`).saada({
 lõpetatud: tõsi,
 });
oodata(vastuseks.statusCode).olla(201);
oodata(vastuseks.keha.andmed.lõpetatud).olla(tõsi);
 });
});

Täidetud väärtus vastuse kehas peaks olema tõene. Ärge unustage URL-i lisada selle üksuse ID, mida soovite värskendada.

Testige DELETE /todos/:id lõpp-punkti

Looge failis index.js lõpp-punkt DELETE. See peaks tagastama ülesandeandmed ilma kustutatud üksuseta.

app.delete("/todos/:id", (req, res) => {
proovi { 
konst id = req.params.id
konst teha = todos[0]
 if (todo) {
todos.liitmine(id, 1)
 }
tagasires.status(200).json({
 andmed: todos,
 viga: null,
 });
 } püüda (viga) {
tagasires.status(500).json({
 andmed: null,
 viga: viga,
 });
 }
});

Lõpp-punkti testimiseks saate kontrollida, kas kustutatud üksus on tagastatud andmetes endiselt olemas:

kirjelda ("Kustutage üks ülesanne", () => {
konst newTodo = {
// tegema
 }
 ennekõike(asünkr () => {
 oota taotlust (baseURL).post("/todo".send (uusTodo);
 })
 see ("peaks kustutama ühe üksuse", asünkroon () => {
konst vastus = ootama päring (baseURL).delete(`/todos/${newTodo.id}`);
konst todos = vastus.keha.andmed
konst eksisteerib = todos.find (todo => {
 newTodo.id == todoId
 })
 oodata (olemas).toBe(määratlemata)
 });
});

DELETE lõpp-punktist tagastatud andmed ei tohiks sisaldada kustutatud üksust. Kuna tagastatud üksused on massiivis, saate kasutada Array[id], et kontrollida, kas API kustutas üksuse õigesti. Tulemus peaks olema vale.

REST API-de loomine

Sellest artiklist õppisite, kuidas testida Express Rest API-d Jest API abil. Kirjutasite HTTP-päringute GET, PUT, POST ja DELETE testid ning nägite, kuidas URL-is ja päringus andmeid lõpp-punkti saata. Peaksite saama neid teadmisi oma Rest API testimisel rakendada.