Testaus, vaikka se voi viedä aikaa, on tärkeä askel minkä tahansa sovelluksen kehityssyklissä. Se varmistaa, että huomaat vikoja ja ongelmia varhaisessa vaiheessa ennen kuin siirrät koodin tuotantoon.

Voit testata Express Rest API: n Jestillä. Kun olet luonut yksinkertaisen CRUD-sovellusliittymän, tutustu testien kirjoittamiseen kullekin päätepisteelle.

Mikä on Jest?

On monia JavaScript-testauskirjastoja, joista voit valita, mutta Jest on helpoin aloittaa. Se on Facebookin kehittämä testauskirjasto, jota käytetään enimmäkseen React-projektien testaamiseen. Voit kuitenkin käyttää sitä myös Node- ja muiden JavaScript-pohjaisten projektien testaamiseen. Se kehitettiin toisen testaustyökalun Jasmine päälle, ja sen mukana tulee oma väitekirjasto.

Vaikka et tarvitse väitekirjastoa testien kirjoittamiseen Jestissä, sinun on käytettävä työkalua HTTP-pyyntöjen tekemiseen. Tässä artikkelissa käytetään SuperTestiä.

Mikä on SuperTest?

Supertesti on solmun testauskirjasto HTTP-kutsuille. Se laajentaa superagenttien testauskirjastoa ja antaa sinun tehdä pyyntöjä, kuten GET, POST, PUT ja DELETE.

instagram viewer

SuperTest tarjoaa pyyntöobjektin, jonka avulla voit tehdä HTTP-pyyntöjä.

konst pyyntö = vaatia("supertest")
pyyntö("https://icanhazdadjoke.com")
.saada('/slack')
.end(toiminto(err, res) {
jos (err) heittää err;
konsoli.Hirsi(res.body.liitteet);
});

Tässä välität API: n perus-URL-osoitteen pyyntöobjektille ja ketjutat sitten HTTP-menetelmän muun URL-osoitteen kanssa. The loppu () menetelmä kutsuu API-palvelinta ja takaisinsoittotoiminto käsittelee sen vastauksen.

Kun saat vastauksen API: lta, voit vahvistaa sen Jestillä.

Luo Express API

Jotta voit testata omia API-päätepisteitäsi, sinun on luotava REST API ensimmäinen. Luotava API on melko yksinkertainen. Se lisää, hakee, päivittää ja poistaa kohteita taulukosta.

Aloita luomalla uusi hakemisto nimeltä node-jest ja alustamalla npm.

mkdir node-jest
npm init -y

Luo seuraavaksi uusi tiedosto nimeltä index.js ja luo Express-palvelin.

konst express = vaatia("ilmaista")
konst sovellus = express()
app.listen (3000, () => console.log("Kuuntele portissa 3000"))

Testaa GET /todos -päätepistettä

Ensimmäinen luomasi päätepiste on GET /todos -päätepiste. Se palauttaa kaikki taulukon kohteet. Lisää indeks.js-tiedostoon seuraava.

konst todos = [
];
// Hae kaikki tehtävät
app.get("/todos", (req, res) => {
palatares.Tila(200).json({
 tiedot: todos,
 virhe: tyhjä,
 });
});

Huomaa, että vastauksen tilakoodi on 200 ja JSON-objekti, joka sisältää tehtävät-kohteen data-nimisessä taulukossa ja virhesanoman. Tätä testaat Jestillä.

Asenna nyt Jest ja SuperTest:

npm Asentaa vitsi supertesti

Lisää sitten testiskripti package.json seuraavasti:

{
"käsikirjoituksia": {
"testata": "vitsi"
 }
}

Ennen kuin aloitat omien testien kirjoittamisen, sinun tulee ymmärtää, miten perustesti kirjoitetaan Jestissä.

Harkitse seuraavaa toimintoa:

toimintosumma(a, b) {
palata a + b;
}
moduuli.vientiä = summa;

Testitiedostossa sinun on:

  • Tuo funktio.
  • Kuvaile mitä testin tulee tehdä.
  • Kutsu toiminto.
  • Vahvista odotettu vastaus funktion todellisella vastauksella. 
konst { summa } = vaatia("./summa")
kuvaile ("Kahden kohteen summa", async() => {
 testata("Sen pitäisi palata 4", () => {
odottaa(summa(2,2)).olla(4)
 })
})

The kuvata avainsana määrittää testien ryhmän ja testata lauseke määrittää tietyn testin. Jos funktiosta palautettu arvo vastaa arvoa, joka on lähetetty olla, testi menee läpi.

Kun testaat API-päätepisteitä, et kutsu funktiota, vaan lähetät pyynnön SuperTestin tai muun HTTP-asiakaskirjaston avulla.

Palaa GET-päätepisteeseen ja luo uusi tiedosto nimeltä api.test.js. Tänne kirjoitat kaikki päätepistetestit. Nimeä testitiedosto kirjaimella a .testata infix varmistaa, että Jest tunnistaa sen testitiedostoksi.

Tuo api.test.js: ssä supertest ja aseta perus-URL seuraavasti:

konst pyyntö = vaatia("supertest")
konst baseURL = "http://paikallinen isäntä: 3000"

Luo seuraavaksi ensimmäinen testi kuvauslohkoon:

kuvaile ("GET /todos", () => {
konst newTodo = {
id: krypto.randomUUID(),
 kohde: "Juoda vettä",
 valmistunut: väärä,
 }
 ennen kaikkea(asynk () => {
// määritä tehtävä
 odota pyyntöä (baseURL).post("/todo").lähetä (uusiTodo);
 })
 kuitenkin(asynk () => {
odottaa request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 se("pitäisi palauttaa 200", async () => {
konst vastaus = odottaa request (baseURL).get("/todos");
odottaa(vastaus.statusCode).olla(200);
odottaa(vastaus.body.virhe).olla(tyhjä);
 });
 se("pitäisi palata todos", async () => {
konst vastaus = odottaa request (baseURL).get("/todos");
 odottaa (response.body.data.length >= 1).olla(totta);
 });
});

Ennen testien suorittamista sinun on määritettävä asennus- ja purkutoiminnot. Nämä funktiot täyttävät todo-taulukon alkiolla ennen testiä ja poistavat valetiedot jokaisen testin jälkeen.

Koodi, joka suoritetaan ennen kaikkia testejä, on beforeAll()-funktiossa. Kaikkien testien jälkeen suoritettava koodi on afterAll()-funktiossa.

Tässä esimerkissä yksinkertaisesti osut kunkin POST- ja DELETE-päätepisteisiin. Todellisessa sovelluksessa muodostat todennäköisesti yhteyden valetietokantaan, joka sisältää testitiedot.

Tässä testissä teit ensin pyynnön GET /todos -päätepisteelle ja vertasit palautettua vastausta odotettuihin tuloksiin. Tämä testisarja läpäisee, jos vastauksella on HTTP-tilakoodi 200, tiedot eivät ole tyhjiä ja virheilmoitus on tyhjä.

Testaa POST /todo -päätepiste

Luo index.js: ssä POST /todo -päätepiste:

app.post("/todo", (req, res) => {
yrittää {
konst { id, item, complete } = req.body;
konst newTodo = {
 id,
 esine,
 valmis,
 };
todos.työntää(uusiTodo);
palatares.Tila(201).json({
 tiedot: todos,
 virhe: tyhjä,
 });
 } ottaa kiinni (virhe) {
palatares.Tila(500).json({
 tiedot: tyhjä,
 virhe: virhe,
 });
 }
});

Tässä testissä sinun on lähetettävä tehtävätiedot pyynnön rungossa käyttämällä send()-menetelmää.

request (baseURL).post("/todo").send (uusiTodo)

POST /todo-pyynnön pitäisi palauttaa tilakoodi 201 ja todos-taulukko, jonka lopussa on lisätty uusi kohde. Tältä testi voi näyttää:

kuvaile ("POSTAA /todo", () => {
konst newTodo = {
// tehdä 
 }
 kuitenkin(asynk () => {
odottaa request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 se("pitäisi lisätä kohde todos-taulukkoon", async () => {
konst vastaus = odottaa request (baseURL).post("/todo").send(newTodo);
konst lastItem = vastaus.body.data[response.body.data.length-1]
odottaa(vastaus.statusCode).olla(201);
odottaa(viimeinen kohde.tuote).olla(uusiTodo["tuote"]);
odottaa(viimeinen kohde.valmis).olla(uusiTodo["valmis"]);
 });
});

Tässä välität todo-tiedot send()-menetelmälle argumenttina. Vastauksessa tulee olla 201-tilakoodi, ja se sisältää myös kaikki tietoobjektin tehtäväkohteet. Testaaksesi, onko todo todella luotu, tarkista, vastaako palautettujen todojen viimeinen merkintä pyynnössä lähettämääsi.

PUT /todos/:id-päätepisteen pitäisi palauttaa päivitetty kohde:

app.put("/todos/:id", (req, res) => {
yrittää {
konst id = req.params.id
konst todo = todos.find((tehtävä) => todo.id == id);
 if(!todo) {
heittääUusiVirhe("Todoa ei löydy")
 }
 todo.completed = req.body.completed;
palatares.Tila(201).json({
 tiedot: todo,
 virhe: tyhjä,
 });
 } ottaa kiinni (virhe) {
palatares.Tila(500).json({
 tiedot: tyhjä,
 virhe: virhe,
 });
 }
});

Testaa vastaus seuraavasti:

kuvaile ("Päivitä yksi tehtävä", () => {
konst newTodo = {
// tehdä 
 }
 ennen kaikkea(asynk () => {
 odota pyyntöä (baseURL).post("/todo").lähetä (uusiTodo);
 })
 kuitenkin(asynk () => {
odottaa request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 se("pitäisi päivittää kohde, jos se on olemassa", async () => {
konst vastaus = odottaa request (baseURL).put(`/todos/${newTodo.id}`).lähettää({
 valmistunut: totta,
 });
odottaa(vastaus.statusCode).olla(201);
odottaa(vastaus.body.data.valmis).olla(totta);
 });
});

Vastaustekstin täytetyn arvon tulee olla tosi. Muista sisällyttää URL-osoitteeseen päivitettävän kohteen tunnus.

Testaa DELETE /todos/:id -päätepistettä

Luo index.js: ssä DELETE-päätepiste. Sen pitäisi palauttaa tehtävätiedot ilman poistettua kohdetta.

app.delete("/todos/:id", (req, res) => {
yrittää { 
konst id = req.params.id
konst tehtävä = todos[0]
 if (todo) {
todos.liitos(id, 1)
 }
palatares.Tila(200).json({
 tiedot: todos,
 virhe: tyhjä,
 });
 } ottaa kiinni (virhe) {
palatares.Tila(500).json({
 tiedot: tyhjä,
 virhe: virhe,
 });
 }
});

Päätepisteen testaamiseksi voit tarkistaa, onko poistettu kohde edelleen olemassa palautetuissa tiedoissa:

kuvaile ("Poista yksi tehtävä", () => {
konst newTodo = {
// tehdä
 }
 ennen kaikkea(asynk () => {
 odota pyyntöä (baseURL).post("/todo").lähetä (uusiTodo);
 })
 se("pitäisi poistaa yksi kohde", async () => {
konst vastaus = odottaa request (baseURL).delete(`/todos/${newTodo.id}`);
konst todos = vastaus.body.data
konst olemassa = todos.find (todo => {
 newTodo.id == todoId
 })
 odottaa (olemassa).toBe(määrittelemätön)
 });
});

DELETE-päätepisteestä palautetut tiedot eivät saa sisältää poistettua kohdetta. Koska palautetut kohteet ovat taulukossa, voit käyttää Array[id]-toimintoa tarkistaaksesi, poistiko API kohteen oikein. Tuloksen pitäisi olla väärä.

REST-sovellusliittymien luominen

Tässä artikkelissa opit testaamaan Express Rest -sovellusliittymää Jest API: n avulla. Kirjoitit testejä GET-, PUT-, POST- ja DELETE HTTP-pyynnöille ja näit kuinka lähettää tietoja päätepisteeseen URL-osoitteessa ja pyynnössä. Sinun pitäisi pystyä soveltamaan tätä tietämystä, kun testaat omaa Rest-sovellusliittymääsi.