Testovanie, hoci môže byť časovo náročné, je dôležitým krokom vo vývojovom cykle akejkoľvek aplikácie. Zabezpečuje, že včas zachytíte chyby a problémy skôr, ako pošlete kód do produkcie.
Jest môžete použiť na testovanie Express Rest API. Po vytvorení jednoduchého CRUD API zistite, ako písať testy pre každý koncový bod.
Čo je Jest?
Existuje veľa testovacích knižníc JavaScript, z ktorých si môžete vybrať, ale Jest je najjednoduchšie začať. Je to testovacia knižnica vyvinutá spoločnosťou Facebook, ktorá sa väčšinou používa na testovanie projektov React. Môžete ho však použiť aj na testovanie Node a iných projektov založených na JavaScripte. Bol vyvinutý nad ďalším testovacím nástrojom Jasmine a je dodávaný s vlastnou knižnicou tvrdení.
Aj keď na písanie testov v Jest nebudete potrebovať knižnicu aserácií, budete musieť použiť nástroj na vytváranie požiadaviek HTTP. Tento článok používa SuperTest.
Čo je to supertest?
SuperTest je knižnica na testovanie uzlov pre volania HTTP. Rozširuje knižnicu testovania superagentov a umožňuje vám zadávať požiadavky ako GET, POST, PUT a DELETE.
SuperTest poskytuje objekt požiadavky, ktorý môžete použiť na vytváranie požiadaviek HTTP.
konšt žiadosť = vyžadovať("supertest")
žiadosť("https://icanhazdadjoke.com")
.get('/slack')
.koniec(funkciu(chyba, res) {
ak (chyba) hodiť chybovať;
konzoly.log(res.telo.prílohy);
});
Tu odovzdáte základnú adresu URL rozhrania API objektu požiadavky a potom zreťazíte metódu HTTP so zvyškom adresy URL. The koniec() metóda volá API server a funkcia spätného volania spracováva jeho odpoveď.
Keď dostanete odpoveď z API, môžete použiť Jest na jej overenie.
Vytvorte expresné API
Ak chcete otestovať svoje vlastné koncové body API, musíte ich vytvoriť REST API najprv. API, ktoré vytvoríte, je celkom jednoduché. Vkladá, načítava, aktualizuje a odstraňuje položky z poľa.
Začnite vytvorením nového adresára s názvom node-jest a inicializáciou npm.
mkdir node-jest
npm init -y
Ďalej vytvorte nový súbor s názvom index.js a vytvorte expresný server.
konšt vyjadriť = vyžadovať("expresné")
konšt app = express()
app.listen (3000, () => console.log("Počúvanie na porte 3000"))
Otestujte koncový bod GET /todos
Prvý koncový bod, ktorý vytvoríte, je koncový bod GET /todos. Vráti všetky položky v poli. V index.js pridajte nasledovné.
konšt todos = [
];
// Získajte všetky úlohy
app.get("/todos", (req, res) => {
vrátiťres.postavenie(200).json({
údaje: todos,
chyba: nulový,
});
});
Všimnite si, že odpoveď má stavový kód 200 a objekt JSON obsahujúci položku úloh v poli s názvom údaje a chybové hlásenie. To je to, čo budete testovať pomocou Jestu.
Teraz nainštalujte Jest a SuperTest:
npm Inštalácia vtip supertest
Potom pridajte testovací skript package.json nasledovne:
{
"skripty": {
"test": "žart"
}
}
Než začnete písať svoje vlastné testy, mali by ste pochopiť, ako napísať základný test v Jeste.
Zvážte nasledujúcu funkciu:
funkciusúčet(a, b) {
vrátiť a + b;
}
modul.exportov = súčet;
V testovacom súbore musíte:
- Importujte funkciu.
- Popíšte, čo má test robiť.
- Zavolajte funkciu.
- Uveďte očakávanú odozvu so skutočnou odozvou funkcie.
konšt { suma } = vyžadovať(./suma")
opísať ("Súčet dvoch položiek", async() => {
test("Mal by sa vrátiť 4", () => {
očakávať(súčet(2,2)).byť(4)
})
})
The popísať kľúčové slovo určuje skupinu testov a test vyhlásenie špecifikuje konkrétny test. Ak sa hodnota vrátená z funkcie zhoduje s hodnotou odovzdanou byť, test prejde.
Pri testovaní koncových bodov API nebudete volať funkciu, ale odosielať požiadavku pomocou SuperTest alebo inej klientskej knižnice HTTP.
Po návrate ku koncovému bodu GET vytvorte nový súbor s názvom api.test.js. Tu budete písať všetky koncové testy. Pomenovanie testovacieho súboru pomocou a .test infix zaisťuje, že ho Jest rozpozná ako testovací súbor.
V api.test.js importujte supertest a nastavte základnú adresu URL takto:
konšt žiadosť = vyžadovať("supertest")
konšt baseURL = "http://localhost: 3000"
Ďalej vytvorte prvý test v bloku popisu:
opísať ("GET /todos", () => {
konšt newTodo = {
id: kryptomeny.randomUUID(),
položka: "Piť vodu",
dokončené: falošný,
}
pred všetkým(async () => {
// nastavenie úlohy
čakať na žiadosť (baseURL).post("/todo").odoslať (newTodo);
})
po všetkom(async () => {
čakať request (baseURL).delete(`/todo/${newTodo.id}`)
})
to ("mal by vrátiť 200", async () => {
konšt odpoveď = čakať request (baseURL).get("/todos");
očakávať(odpoveď.statusCode).byť(200);
očakávať(odpoveď.telo.chyba).byť(nulový);
});
to ("by sa mal vrátiť k úlohám", async () => {
konšt odpoveď = čakať request (baseURL).get("/todos");
očakávať (odpoveď.telo.údaje.dĺžka >= 1).byť(pravda);
});
});
Pred spustením testov budete musieť definovať funkcie nastavenia a rozloženia. Tieto funkcie naplnia pole úloh položkou pred testom a po každom teste vymažú fiktívne údaje.
Kód, ktorý sa spustí pred všetkými testami, je vo funkcii beforeAll(). Kód, ktorý sa spustí po všetkých testoch, je vo funkcii afterAll().
V tomto príklade jednoducho stlačíte koncové body POST a DELETE pre každý z nich. V skutočnej aplikácii by ste sa pravdepodobne pripojili k simulovanej databáze obsahujúcej testovacie údaje.
V tomto teste ste najprv zadali požiadavku na koncový bod GET /todos a porovnali odoslanú odpoveď s očakávanými výsledkami. Táto testovacia sada prejde, ak odpoveď obsahuje príponu Stavový kód HTTP z 200, údaje nie sú prázdne a chybové hlásenie je nulové.
Otestujte koncový bod POST /todo
V index.js vytvorte koncový bod POST /todo:
app.post("/todo", (req, res) => {
skúste {
konšt { id, položka, dokončené } = req.body;
konšt newTodo = {
id,
položka,
dokončené,
};
todos.TLAČIŤ(newTodo);
vrátiťres.postavenie(201).json({
údaje: todos,
chyba: nulový,
});
} chytiť (chyba) {
vrátiťres.postavenie(500).json({
údaje: nulový,
chyba: chyba,
});
}
});
V tomto teste budete musieť odoslať podrobnosti o úlohe v tele požiadavky pomocou metódy send().
žiadosť (baseURL).post("/todo").odoslať (newTodo)
Požiadavka POST /todo by mala vrátiť stavový kód 201 a pole úloh s novou položkou pridanou na konci. Takto môže test vyzerať:
opísať ("POST /todo", () => {
konšt newTodo = {
// robiť
}
po všetkom(async () => {
čakať request (baseURL).delete(`/todo/${newTodo.id}`)
})
to ("by mal pridať položku do poľa úloh", async () => {
konšt odpoveď = čakať request (baseURL).post("/todo").send(newTodo);
konšt lastItem = response.body.data[response.body.data.length-1]
očakávať(odpoveď.statusCode).byť(201);
očakávať(lastItem.položka).byť(newTodo["položka"]);
očakávať(lastItem.dokončené).byť(newTodo["dokončené"]);
});
});
Tu odovzdávate údaje úloh metóde send() ako argument. Odpoveď by mala mať stavový kód 201 a tiež obsahovať všetky položky úloh v dátovom objekte. Ak chcete otestovať, či bola úloha skutočne vytvorená, skontrolujte, či sa posledný záznam vo vrátených úlohách zhoduje s tým, ktorý ste odoslali v žiadosti.
Koncový bod PUT /todos/:id by mal vrátiť aktualizovanú položku:
app.put("/todos/:id", (req, res) => {
skúste {
konšt id = req.params.id
konšt todo = todos.find((todo) => todo.id == id);
if(!todo) {
hodiťNovýChyba("Todo sa nenašlo")
}
todo.completed = req.body.completed;
vrátiťres.postavenie(201).json({
údaje: todo,
chyba: nulový,
});
} chytiť (chyba) {
vrátiťres.postavenie(500).json({
údaje: nulový,
chyba: chyba,
});
}
});
Otestujte odpoveď nasledovne:
opísať ("Aktualizujte jednu úlohu", () => {
konšt newTodo = {
// robiť
}
pred všetkým(async () => {
čakať na žiadosť (baseURL).post("/todo").odoslať (newTodo);
})
po všetkom(async () => {
čakať request (baseURL).delete(`/todo/${newTodo.id}`)
})
to ("by mal aktualizovať položku, ak existuje", async () => {
konšt odpoveď = čakať požiadavka (baseURL).put(`/todos/${newTodo.id}`).odoslať({
dokončené: pravda,
});
očakávať(odpoveď.statusCode).byť(201);
očakávať(odpoveď.telo.údaje.dokončené).byť(pravda);
});
});
Dokončená hodnota v tele odpovede by mala byť pravdivá. Nezabudnite do adresy URL zahrnúť ID položky, ktorú chcete aktualizovať.
Otestujte koncový bod DELETE /todos/:id
V index.js vytvorte koncový bod DELETE. Mal by vrátiť údaje o úlohe bez odstránenej položky.
app.delete("/todos/:id", (req, res) => {
skúste {
konšt id = req.params.id
konšt todo = todos[0]
if (todo) {
todos.splietať(id, 1)
}
vrátiťres.postavenie(200).json({
údaje: todos,
chyba: nulový,
});
} chytiť (chyba) {
vrátiťres.postavenie(500).json({
údaje: nulový,
chyba: chyba,
});
}
});
Ak chcete otestovať koncový bod, môžete skontrolovať, či odstránená položka stále existuje vo vrátených údajoch:
opísať ("Odstrániť jednu úlohu", () => {
konšt newTodo = {
// robiť
}
pred všetkým(async () => {
čakať na žiadosť (baseURL).post("/todo").odoslať (newTodo);
})
to ("mali odstrániť jednu položku", async () => {
konšt odpoveď = čakať request (baseURL).delete(`/todos/${newTodo.id}`);
konšt todos = response.body.data
konšt existuje = todos.find (todo => {
newTodo.id == todoId
})
očakávať (existuje).byť(nedefinované)
});
});
Údaje vrátené z koncového bodu DELETE by nemali obsahovať vymazanú položku. Keďže vrátené položky sú v poli, môžete použiť Array[id] na kontrolu, či API odstránilo položku správne. Výsledok by mal byť nepravdivý.
Vytváranie REST API
V tomto článku ste sa naučili, ako testovať Express Rest API pomocou Jest API. Napísali ste testy pre požiadavky GET, PUT, POST a DELETE HTTP a videli ste, ako odoslať údaje do koncového bodu v adrese URL a požiadavke. Tieto znalosti by ste mali vedieť uplatniť pri testovaní vlastného Rest API.