A tesztelés, bár időigényes lehet, minden alkalmazás fejlesztési ciklusának fontos lépése. Gondoskodik arról, hogy már korán felismerje a hibákat és problémákat, mielőtt a kódot éles verzióba helyezi.
A Jest segítségével tesztelheti az Express Rest API-t. Miután létrehozott egy egyszerű CRUD API-t, fedezze fel, hogyan írhat teszteket az egyes végpontokhoz.
Mi az a Jest?
Számos JavaScript tesztelési könyvtár közül választhat, de Tréfa ezzel a legkönnyebb kezdeni. Ez a Facebook által kifejlesztett tesztelési könyvtár, amelyet többnyire a React projektek tesztelésére használnak. Használhatja azonban a Node és más JavaScript-alapú projektek tesztelésére is. A Jasmine, egy másik tesztelőeszköz tetején fejlesztették ki, és saját állítási könyvtárával együtt érkezik.
Noha nincs szükség állítási könyvtárra a tesztek Jestben történő írásához, HTTP-kérésekhez eszközt kell használnia. Ez a cikk a SuperTestet használja.
Mi az a SuperTest?
Szuperteszt egy csomópont-tesztelési könyvtár a HTTP-hívásokhoz. Kibővíti a szuperügynök tesztelési könyvtárát, és lehetővé teszi olyan kérések benyújtását, mint a GET, POST, PUT és DELETE.
A SuperTest egy kérési objektumot biztosít, amellyel HTTP kéréseket küldhet.
const kérés = igényelnek("szupertest")
kérés("https://icanhazdadjoke.com")
.kap('/slack')
.end(funkció(hiba, res) {
ha (téved) dobás téved;
konzol.log(res.test.mellékletek);
});
Itt átadja az API alap URL-jét a kérelem objektumnak, majd a HTTP metódust az URL többi részével láncolja. Az vége() metódus meghívja az API-kiszolgálót, és a visszahívási függvény kezeli a válaszát.
Miután megkapta a választ az API-tól, a Jest segítségével ellenőrizheti azt.
Hozzon létre egy Express API-t
A saját API-végpontjainak teszteléséhez létre kell hoznia egy REST API első. A létrehozandó API meglehetősen egyszerű. Beszúr, lekér, frissít és töröl elemeket egy tömbből.
Kezdje egy új, node-jest nevű könyvtár létrehozásával és az npm inicializálásával.
mkdir node-jest
npm init -y
Ezután hozzon létre egy új fájlt, melynek neve index.js és hozza létre az Express szervert.
const expressz = igényelnek("Expressz")
const app = express()
app.listen (3000, () => console.log("Hallgatás a 3000-es porton"))
Tesztelje a GET /todos végpontot
Az első létrehozandó végpont a GET /todos végpont. Visszaadja a tömb összes elemét. Az index.js fájlban adja hozzá a következőket.
const todos = [
];
// Get all todos
app.get("/todos", (req, res) => {
Visszatérésres.állapot(200).json({
adatok: todos,
hiba: nulla,
});
});
Vegye figyelembe, hogy a válasz 200-as állapotkóddal és egy JSON-objektummal rendelkezik, amely egy adat nevű tömbben tartalmazza a teendőket és egy hibaüzenetet. Ezt fogja tesztelni a Jest használatával.
Most telepítse a Jest és a SuperTestet:
npm telepítés tréfa szuperteszt
Ezután adjon hozzá egy tesztszkriptet package.json alábbiak szerint:
{
"forgatókönyvek": {
"teszt": "tréfa"
}
}
Mielőtt elkezdené saját tesztjeit írni, meg kell értenie, hogyan írhat alaptesztet a Jestben.
Vegye figyelembe a következő funkciót:
funkcióösszeg(a, b) {
Visszatérés a + b;
}
modult.export = összeg;
A tesztfájlban a következőket kell tennie:
- Importálja a függvényt.
- Írja le, mit kell tennie a tesztnek.
- Hívja meg a függvényt.
- Állítsa be a várt választ a függvény tényleges válaszával.
const { összeg } = igényelnek("./összeg")
leír("Két tétel összege", async() => {
teszt("4-et kell visszaadnia", () => {
elvárják(összeg(2,2)).lenni(4)
})
})
Az leírni kulcsszó határozza meg a tesztek csoportját és a teszt utasítás határozza meg a konkrét tesztet. Ha a függvénytől visszaadott érték megegyezik a következőnek átadott értékkel lenni, a teszt sikeres.
Az API-végpontok tesztelésekor nem függvényt kell meghívnia, hanem kérést küld a SuperTest vagy egy másik HTTP-ügyfélkönyvtár használatával.
Visszatérve a GET végponthoz, hozzon létre egy új nevű fájlt api.test.js. Ide kell írni az összes végponttesztet. A tesztfájl elnevezése a .teszt Az infix biztosítja, hogy a Jest tesztfájlként ismerje fel.
Az api.test.js fájlban importálja a szupertestet, és állítsa be az alap URL-t a következőképpen:
const kérés = igényelnek("szupertest")
const baseURL = "http://localhost: 3000"
Ezután hozza létre az első tesztet a leírási blokkban:
leír("GET /todos", () => {
const newTodo = {
id: kripto.randomUUID(),
tétel: "Vizet inni",
elkészült: hamis,
}
minden előtt(async () => {
// állítsd be a teendőt
kérésre vár (baseURL).post("/todo").send (newTodo);
})
végül(async () => {
várják kérés (baseURL).delete(`/todo/${newTodo.id}`)
})
azt("200-at kell visszaadnia", aszinkron () => {
const válasz = várják kérés (alapURL).get("/todos");
elvárják(válasz.statusCode).lenni(200);
elvárják(válasz.test.hiba).lenni(nulla);
});
azt("vissza kell térnie a todoshoz", aszinkron () => {
const válasz = várják kérés (alapURL).get("/todos");
várható (response.body.data.length >= 1).lenni(igaz);
});
});
A tesztek futtatása előtt meg kell határoznia a beállítási és lebontási funkciókat. Ezek a függvények feltöltik a todo tömböt egy elemmel a teszt előtt, és minden teszt után törlik az áladatokat.
Az összes teszt előtt lefutó kód a beforeAll() függvényben található. Az összes teszt után lefutó kód az afterAll() függvényben található.
Ebben a példában egyszerűen leüti a POST és a DELETE végpontokat mindegyiknél. Egy valós alkalmazásban valószínűleg a tesztadatokat tartalmazó áladatbázishoz csatlakozna.
Ebben a tesztben először kért a GET /todos végponthoz, és összehasonlította a visszaküldött választ a várt eredményekkel. Ez a tesztcsomag sikeres lesz, ha a válasz egy HTTP állapotkód 200, az adatok nem üresek, és a hibaüzenet nulla.
Tesztelje a POST /todo végpontot
Az index.js fájlban hozza létre a POST /todo végpontot:
app.post("/todo", (req, res) => {
próbálja meg {
const { azonosító, tétel, elkészült } = igénytörzs;
const newTodo = {
azonosító,
tétel,
befejezve,
};
todos.nyom(newTodo);
Visszatérésres.állapot(201).json({
adatok: todos,
hiba: nulla,
});
} fogás (hiba) {
Visszatérésres.állapot(500).json({
adat: nulla,
hiba: hiba,
});
}
});
Ebben a tesztben el kell küldenie a feladat részleteit a kérés törzsében a send() metódussal.
kérés (baseURL).post("/todo").send (newTodo)
A POST /todo kérésnek 201-es állapotkódot és a todos tömböt kell visszaadnia az új elemmel a végén. Így nézhet ki a teszt:
leír("POST /todo", () => {
const newTodo = {
// csinálni
}
végül(async () => {
várják kérés (baseURL).delete(`/todo/${newTodo.id}`)
})
azt("hozzá kell adnia egy elemet a todos tömbhöz", aszinkron () => {
const válasz = várják kérés (baseURL).post("/todo").send(newTodo);
const lastItem = válasz.body.data[válasz.test.adat.length-1]
elvárják(válasz.statusCode).lenni(201);
elvárják(utolsó elem.tétel).lenni(newTodo["tétel"]);
elvárják(utolsó elem.befejezte).lenni(newTodo["befejezve"]);
});
});
Itt a todo adatokat a send() metódusnak adja át argumentumként. A válasznak 201-es állapotkóddal kell rendelkeznie, és tartalmaznia kell az adatobjektum összes teendőjét is. Annak teszteléséhez, hogy a todo valóban létrejött-e, ellenőrizze, hogy a visszaadott todos utolsó bejegyzése megegyezik-e a kérésben elküldött bejegyzéssel.
A PUT /todos/:id végpontnak a frissített elemet kell visszaadnia:
app.put("/todos/:id", (req, res) => {
próbálja meg {
const id = req.params.id
const todo = todos.find((todo) => todo.id == id);
if(!todo) {
dobásújHiba("Todo nem található")
}
todo.completed = req.body.completed;
Visszatérésres.állapot(201).json({
adatok: todo,
hiba: nulla,
});
} fogás (hiba) {
Visszatérésres.állapot(500).json({
adat: nulla,
hiba: hiba,
});
}
});
Tesztelje a választ a következőképpen:
leír("Frissítsen egy teendőt", () => {
const newTodo = {
// csinálni
}
minden előtt(async () => {
kérésre vár (baseURL).post("/todo").send (newTodo);
})
végül(async () => {
várják kérés (baseURL).delete(`/todo/${newTodo.id}`)
})
azt("frissítenie kell az elemet, ha létezik", aszinkron () => {
const válasz = várják kérés (baseURL).put(`/todos/${newTodo.id}`).Küld({
elkészült: igaz,
});
elvárják(válasz.statusCode).lenni(201);
elvárják(válasz.test.adat.befejezte).lenni(igaz);
});
});
A választörzsben szereplő kitöltött értéknek igaznak kell lennie. Ne felejtse el megadni a frissíteni kívánt elem azonosítóját az URL-ben.
Tesztelje a DELETE /todos/:id végpontot
Az index.js fájlban hozza létre a DELETE végpontot. Vissza kell adnia a teendő adatokat a törölt elem nélkül.
app.delete("/todos/:id", (req, res) => {
próbálja meg {
const id = req.params.id
const todo = todos[0]
if (todo) {
todos.illesztés(id, 1)
}
Visszatérésres.állapot(200).json({
adatok: todos,
hiba: nulla,
});
} fogás (hiba) {
Visszatérésres.állapot(500).json({
adat: nulla,
hiba: hiba,
});
}
});
A végpont teszteléséhez ellenőrizheti, hogy a törölt elem még mindig létezik-e a visszaadott adatok között:
leír("Töröljön egy teendőt", () => {
const newTodo = {
// csinálni
}
minden előtt(async () => {
kérésre vár (baseURL).post("/todo").send (newTodo);
})
azt("törölnie kell egy elemet", aszinkron () => {
const válasz = várják kérés (baseURL).delete(`/todos/${newTodo.id}`);
const todos = válasz.test.adatok
const létezik = todos.find (todo => {
newTodo.id == todoId
})
elvár (létezik).toBe(meghatározatlan)
});
});
A DELETE végponttól visszaküldött adatok nem tartalmazhatják a törölt elemet. Mivel a visszaadott elemek egy tömbben vannak, az Array[id] segítségével ellenőrizheti, hogy az API megfelelően törölte-e az elemet. Az eredménynek hamisnak kell lennie.
REST API-k létrehozása
Ebből a cikkből megtanulta, hogyan tesztelhet egy Express Rest API-t a Jest API használatával. Teszteket írt a GET, PUT, POST és DELETE HTTP kérésekhez, és látta, hogyan lehet adatokat küldeni a végponthoz az URL-ben és a kérésben. Ezt a tudást alkalmaznia kell saját Rest API tesztelésekor.
