בדיקה, למרות שהיא יכולה להיות גוזלת זמן, היא שלב חשוב במחזור הפיתוח של כל אפליקציה. זה מבטיח לך לתפוס באגים ובעיות בשלב מוקדם לפני שאתה דוחף קוד לייצור.

אתה יכול להשתמש ב-Jest כדי לבדוק ממשק API של Express Rest. לאחר שיצרת ממשק API פשוט של CRUD, גלה כיצד לכתוב בדיקות עבור כל נקודת קצה.

מה זה ג'סט?

ישנן ספריות בדיקות JavaScript רבות שאתה יכול לבחור מהן, אבל צְחוֹק הכי קל להתחיל איתו. זוהי ספריית בדיקות שפותחה על ידי פייסבוק, המשמשת בעיקר לבדיקת פרויקטים של React. עם זאת, אתה יכול להשתמש בו גם כדי לבדוק את Node ופרויקטים אחרים מבוססי JavaScript. הוא פותח על גבי Jasmine, כלי בדיקה נוסף, ומגיע עם ספריית הצהרות משלו.

אמנם לא תזדקק לספריית הצהרות כדי לכתוב מבחנים ב-Jest, אבל תצטרך להשתמש בכלי כדי לבצע בקשות HTTP. מאמר זה משתמש ב-SuperTest.

מה זה SuperTest?

מבחן סופר היא ספריית בדיקת Node עבור קריאות HTTP. זה מרחיב את ספריית בדיקות העל ומאפשר לך לבצע בקשות כמו GET, POST, PUT ו-DELETE.

SuperTest מספק אובייקט בקשה שתוכל להשתמש בו כדי לבצע בקשות HTTP.

const בקשה = לִדרוֹשׁ("סופר מבחן")
בַּקָשָׁה("https://icanhazdadjoke.com





instagram viewer


")
.לקבל('/slack')
.סוֹף(פוּנקצִיָה(טעות, מילואים) {
אם (לִטְעוֹת) לזרוק לִטְעוֹת;
לְנַחֵם.עֵץ(מילואים.גוּף.קבצים מצורפים);
});

כאן, אתה מעביר את כתובת האתר הבסיסית של ה-API לאובייקט הבקשה ולאחר מכן משרשרת את שיטת ה-HTTP עם שאר כתובת האתר. ה סוֹף() השיטה קוראת לשרת ה-API ופונקציית ה-callback מטפלת בתגובה שלו.

ברגע שתקבל את התגובה מה-API, תוכל להשתמש ב-Jest כדי לאמת אותה.

צור API Express

כדי לבדוק את נקודות הקצה של ה-API שלך, עליך ליצור ממשק API של REST ראשון. ה-API שתיצור הוא די פשוט. הוא מוסיף, מאחזר, מעדכן ומוחק פריטים ממערך.

התחל ביצירת ספרייה חדשה בשם node-jest ואתחול npm.

mkdir node-jest
npm init -y

לאחר מכן, צור קובץ חדש בשם index.js ו ליצור את שרת האקספרס.

const express = לִדרוֹשׁ("אֶקְסְפּרֶס")
const app = express()
app.listen (3000, () => console.log("מאזין בנמל 3000"))

בדוק את נקודת הקצה GET /todos

נקודת הקצה הראשונה שתיצור היא נקודת הקצה GET /todos. זה מחזיר את כל הפריטים במערך. ב-index.js, הוסף את הדברים הבאים.

const מטלות = [
];
// קבל את כל המשימות
app.get("/todos", (req, res) => {
לַחֲזוֹרמילואים.סטָטוּס(200)‎.json({
 נתונים: todos,
 שְׁגִיאָה: ריק,
 });
});

שימו לב שלתגובה יש קוד סטטוס של 200 ואובייקט JSON המכיל את פריט המטלות במערך שנקרא נתונים והודעת שגיאה. זה מה שתבדוק באמצעות Jest.

כעת, התקן את Jest ו-SuperTest:

npm להתקין מבחן על צוחק

לאחר מכן, הוסף סקריפט בדיקה package.json כדלהלן:

{
"תסריטים": {
"מִבְחָן": "צְחוֹק"
 }
}

לפני שתתחיל לכתוב מבחנים משלך, עליך להבין כיצד לכתוב מבחן בסיסי בג'סט.

שקול את הפונקציה הבאה:

פוּנקצִיָהסְכוּם(א, ב) {
לַחֲזוֹר a + b;
}
מודול.יצוא = סכום;

בקובץ הבדיקה, עליך:

  • ייבא את הפונקציה.
  • תאר מה הבדיקה צריכה לעשות.
  • קרא לפונקציה.
  • קבע את התגובה הצפויה עם התגובה בפועל מהפונקציה. 
const { sum } = לִדרוֹשׁ("./סְכוּם")
לְתַאֵר("סכום של שני פריטים", async() => {
 מִבְחָן("זה אמור להחזיר 4", () => {
לְצַפּוֹת(סְכוּם(2,2)).להיות(4)
 })
})

ה לְתַאֵר מילת מפתח מציינת את קבוצת הבדיקות ואת מִבְחָן הצהרה מציינת את המבחן הספציפי. אם הערך שהוחזר מהפונקציה תואם לערך שהועבר אליו להיות, המבחן עובר.

בעת בדיקת נקודות קצה API, לא תתקשר לפונקציה אלא תשלח בקשה באמצעות SuperTest או ספריית לקוח HTTP אחרת.

חזרה לנקודת הקצה GET, צור קובץ חדש בשם api.test.js. כאן תכתוב את כל מבחני הקצה. מתן שם לקובץ הבדיקה עם א .מִבְחָן infix מבטיח ש-Jest מזהה אותו כקובץ בדיקה.

ב-api.test.js, ייבא את supertest והגדר את כתובת האתר הבסיסית כך:

const בקשה = לִדרוֹשׁ("סופר מבחן")
const baseURL = "http://localhost: 3000"

לאחר מכן, צור את המבחן הראשון בבלוק התיאור:

לְתַאֵר("קבל /todos", () => {
const newTodo = {
תְעוּדַת זֶהוּת: קריפטו.randomUUID(),
 פריט: "לשתות מים",
 הושלם: שֶׁקֶר,
 }
 לפני הכל(אסינכרון () => {
// הגדר את המשימות
 await request (baseURL).post("/todo").send (newTodo);
 })
 אחרי הכל(אסינכרון () => {
לְהַמתִין request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 זה("צריך להחזיר 200", אסינכרון () => {
const תגובה = לְהַמתִין request (baseURL).get("/todos");
לְצַפּוֹת(תְגוּבָה.statusCode).להיות(200);
לְצַפּוֹת(תְגוּבָה.גוּף.שְׁגִיאָה).להיות(ריק);
 });
 זה("צריך להחזיר מטלות", אסינכרון () => {
const תגובה = לְהַמתִין request (baseURL).get("/todos");
 expect (response.body.data.length >= 1).להיות(נָכוֹן);
 });
});

לפני הפעלת הבדיקות, יהיה עליך להגדיר פונקציות הגדרה והפסקה. פונקציות אלו יאכלסו את מערך ה-todo בפריט לפני הבדיקה וימחקו את נתוני הדמה לאחר כל בדיקה.

הקוד שרץ לפני כל הבדיקות נמצא בפונקציה beforeAll(). הקוד שרץ לאחר כל הבדיקות נמצא בפונקציה afterAll() .

בדוגמה זו, אתה פשוט פוגע בנקודות הקצה POST ו-DELETE עבור כל אחת מהן. באפליקציה אמיתית, סביר להניח שתתחבר למסד נתונים מדומה המכיל את נתוני הבדיקה.

בבדיקה זו הגשת תחילה בקשה לנקודת הקצה GET /todos והשווית את התגובה שנשלחה בחזרה לתוצאות הצפויות. חבילת בדיקה זו תעבור אם לתגובה יש קוד מצב HTTP מתוך 200, הנתונים אינם ריקים, והודעת השגיאה היא null.

בדוק את נקודת הקצה POST /todo

ב-index.js, צור את נקודת הקצה POST /todo:

app.post("/todo", (req, res) => {
לְנַסוֹת {
const { id, item, completed } = req.body;
const newTodo = {
 תְעוּדַת זֶהוּת,
 פריט,
 הושלם,
 };
לעשות.לִדחוֹף(newTodo);
לַחֲזוֹרמילואים.סטָטוּס(201)‎.json({
 נתונים: todos,
 שְׁגִיאָה: ריק,
 });
 } לתפוס (שגיאה) {
לַחֲזוֹרמילואים.סטָטוּס(500)‎.json({
 נתונים: ריק,
 שגיאה: שגיאה,
 });
 }
});

בבדיקה זו, תצטרך לשלוח את פרטי ה-todo בגוף הבקשה בשיטת send() .

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

בקשת ה-POST /todo אמורה להחזיר קוד סטטוס 201 ואת מערך המשימות עם הפריט החדש שנוסף בסוף. כך עשויה להיראות המבחן:

לְתַאֵר("POST /todo", () => {
const newTodo = {
// לעשות 
 }
 אחרי הכל(אסינכרון () => {
לְהַמתִין request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 זה("צריך להוסיף פריט למערך todos", אסינכרון () => {
const תגובה = לְהַמתִין request (baseURL).post("/todo").send(newTodo);
const lastItem = response.body.data[response.body.data.length-1]
לְצַפּוֹת(תְגוּבָה.statusCode).להיות(201);
לְצַפּוֹת(פריט אחרון.פריט).להיות(newTodo["פריט"]);
לְצַפּוֹת(פריט אחרון.הושלם).להיות(newTodo["הושלם"]);
 });
});

כאן, אתה מעביר את נתוני ה-todo לשיטת send() כארגומנט. על התגובה להיות קוד סטטוס 201 ולהכיל גם את כל פריטי המטלות באובייקט נתונים. כדי לבדוק אם ה-todo אכן נוצר, בדקו האם הערך האחרון ב-todos שהוחזר תואם לזה ששלחתם בבקשה.

נקודת הקצה PUT /todos/:id אמורה להחזיר את הפריט המעודכן:

app.put("/todos/:id", (req, res) => {
לְנַסוֹת {
const id = req.params.id
const todo = todos.find((todo) => todo.id == id);
 if(!todo) {
לזרוקחָדָשׁשְׁגִיאָה("טודו לא נמצא")
 }
 todo.completed = req.body.completed;
לַחֲזוֹרמילואים.סטָטוּס(201)‎.json({
 נתונים: Todo,
 שְׁגִיאָה: ריק,
 });
 } לתפוס (שגיאה) {
לַחֲזוֹרמילואים.סטָטוּס(500)‎.json({
 נתונים: ריק,
 שגיאה: שגיאה,
 });
 }
});

בדוק את התגובה באופן הבא:

לְתַאֵר("עדכן מטלה אחת", () => {
const newTodo = {
// לעשות 
 }
 לפני הכל(אסינכרון () => {
 await request (baseURL).post("/todo").send (newTodo);
 })
 אחרי הכל(אסינכרון () => {
לְהַמתִין request (baseURL).delete(`/todo/${newTodo.id}`)
 })
 זה("צריך לעדכן פריט אם הוא קיים", אסינכרון () => {
const תגובה = לְהַמתִין request (baseURL).put(`/todos/${newTodo.id}`).לִשְׁלוֹחַ({
 הושלם: נָכוֹן,
 });
לְצַפּוֹת(תְגוּבָה.statusCode).להיות(201);
לְצַפּוֹת(תְגוּבָה.גוּף.נתונים.הושלם).להיות(נָכוֹן);
 });
});

הערך המושלם בגוף התגובה צריך להיות נכון. זכור לכלול את המזהה של הפריט שברצונך לעדכן בכתובת האתר.

בדוק את נקודת הקצה DELETE /todos/:id

ב-index.js, צור את נקודת הקצה DELETE. זה אמור להחזיר את נתוני המטלות ללא הפריט שנמחק.

app.delete("/todos/:id", (req, res) => {
לְנַסוֹת { 
const id = req.params.id
const todo = todos[0]
 if (todo) {
לעשות.אִחוּי(תְעוּדַת זֶהוּת, 1)
 }
לַחֲזוֹרמילואים.סטָטוּס(200)‎.json({
 נתונים: todos,
 שְׁגִיאָה: ריק,
 });
 } לתפוס (שגיאה) {
לַחֲזוֹרמילואים.סטָטוּס(500)‎.json({
 נתונים: ריק,
 שגיאה: שגיאה,
 });
 }
});

כדי לבדוק את נקודת הקצה, אתה יכול לבדוק אם הפריט שנמחק עדיין קיים בנתונים המוחזרים:

לְתַאֵר("מחק מטלה אחת", () => {
const newTodo = {
// לעשות
 }
 לפני הכל(אסינכרון () => {
 await request (baseURL).post("/todo").send (newTodo);
 })
 זה("צריך למחוק פריט אחד", אסינכרון () => {
const תגובה = לְהַמתִין request (baseURL).delete(`/todos/${newTodo.id}`);
const todos = response.body.data
const exists = todos.find (todo => {
 newTodo.id == todoId
 })
 מצפה (קיים).toBe(לא מוגדר)
 });
});

הנתונים המוחזרים מנקודת הקצה DELETE לא צריכים להכיל את הפריט שנמחק. מכיוון שהפריטים המוחזרים נמצאים במערך, אתה יכול להשתמש ב-Array[id] כדי לבדוק אם ה-API מחק את הפריט בצורה נכונה. התוצאה צריכה להיות שקרית.

יצירת ממשקי API של REST

במאמר זה למדת כיצד לבדוק Express Rest API באמצעות Jest API. כתבת בדיקות עבור בקשות ה-GET, PUT, POST ו-DELETE HTTP וראית איך לשלוח נתונים לנקודת הקצה בכתובת ה-URL ובבקשה. אתה אמור להיות מסוגל ליישם את הידע הזה בעת בדיקת Rest API משלך.