Das Testen kann zwar zeitaufwändig sein, ist aber ein wichtiger Schritt im Entwicklungszyklus jeder Anwendung. Es stellt sicher, dass Sie Fehler und Probleme frühzeitig erkennen, bevor Sie Code in die Produktion übertragen.
Sie können Jest verwenden, um eine Express-Rest-API zu testen. Nachdem Sie eine einfache CRUD-API erstellt haben, erfahren Sie, wie Sie Tests für jeden Endpunkt schreiben.
Was ist Scherz?
Es gibt viele JavaScript-Testbibliotheken, aus denen Sie auswählen können, aber Scherz ist am einfachsten anzufangen. Es ist eine von Facebook entwickelte Testbibliothek, die hauptsächlich zum Testen von React-Projekten verwendet wird. Sie können es jedoch auch zum Testen von Node und anderen JavaScript-basierten Projekten verwenden. Es wurde auf Basis von Jasmine, einem weiteren Testtool, entwickelt und wird mit einer eigenen Assertion-Bibliothek geliefert.
Während Sie keine Assertion-Bibliothek benötigen, um Tests in Jest zu schreiben, müssen Sie ein Tool verwenden, um HTTP-Anforderungen zu stellen. Dieser Artikel verwendet SuperTest.
Was ist SuperTest?
SuperTest ist eine Knotentestbibliothek für HTTP-Aufrufe. Es erweitert die Superagent-Testbibliothek und ermöglicht es Ihnen, Anforderungen wie GET, POST, PUT und DELETE zu stellen.
SuperTest stellt ein Anforderungsobjekt bereit, das Sie verwenden können, um HTTP-Anforderungen zu stellen.
konst Anfrage = benötigen("Supertest")
Anfrage("https://icanhazdadjoke.com")
.erhalten('/slack')
.Ende(Funktion(ähm, res) {
wenn (irren) Wurf irren;
Konsole.Protokoll(res.Karosserie.Anhänge);
});
Hier übergeben Sie die Basis-URL der API an das Anforderungsobjekt und verketten dann die HTTP-Methode mit dem Rest der URL. Das Ende() -Methode ruft den API-Server auf und die Callback-Funktion verarbeitet ihre Antwort.
Sobald Sie die Antwort von der API erhalten haben, können Sie sie mit Jest validieren.
Erstellen Sie eine Express-API
Um Ihre eigenen API-Endpunkte zu testen, müssen Sie erstellen eine REST-API Erste. Die API, die Sie erstellen werden, ist recht einfach. Es fügt Elemente aus einem Array ein, ruft sie ab, aktualisiert und löscht sie.
Erstellen Sie zunächst ein neues Verzeichnis namens node-jest und initialisieren Sie npm.
mkdir node-jest
npm init -y
Erstellen Sie als Nächstes eine neue Datei mit dem Namen index.js und Erstellen Sie den Express-Server.
konst ausdrücken = benötigen("ausdrücken")
konst app = ausdrücken()
app.listen (3000, () => Konsole.log ("Hören auf Port 3000"))
Testen Sie den GET /todos-Endpunkt
Der erste Endpunkt, den Sie erstellen, ist der GET /todos-Endpunkt. Es gibt alle Elemente im Array zurück. Fügen Sie in index.js Folgendes hinzu.
konst todos = [
];
// Alle Aufgaben abrufen
app.get("/todos", (req, res) => {
Rückkehrres.Status(200).json({
Daten: todos,
Error: Null,
});
});
Beachten Sie, dass die Antwort einen Statuscode von 200 und ein JSON-Objekt enthält, das das Aufgabenelement in einem Array namens data und eine Fehlermeldung enthält. Dies werden Sie mit Jest testen.
Installieren Sie jetzt Jest und SuperTest:
npm Installieren Witz Supertest
Fügen Sie dann ein Testskript hinzu Paket.json folgendermaßen:
{
"Skripte": {
"Prüfung": "Scherz"
}
}
Bevor Sie anfangen, Ihre eigenen Tests zu schreiben, sollten Sie verstehen, wie man einen einfachen Test in Jest schreibt.
Betrachten Sie die folgende Funktion:
FunktionSumme(ein, b) {
Rückkehr a + b;
}
Modul.Exporte = Summe;
In der Testdatei müssen Sie:
- Importieren Sie die Funktion.
- Beschreiben Sie, was der Test leisten soll.
- Rufen Sie die Funktion auf.
- Assertieren Sie die erwartete Antwort mit der tatsächlichen Antwort von der Funktion.
konst {Summe} = benötigen("./Summe")
beschreiben("Summe zweier Artikel", async() => {
Prüfung("Es sollte 4 zurückgeben", () => {
erwarten von(Summe(2,2)).sein(4)
})
})
Das beschreiben Schlüsselwort spezifiziert die Testgruppe und die Prüfung Anweisung gibt den spezifischen Test an. Wenn der von der Funktion zurückgegebene Wert mit dem übergebenen Wert übereinstimmt sein, der Test ist bestanden.
Beim Testen von API-Endpunkten rufen Sie keine Funktion auf, sondern senden eine Anfrage mit SuperTest oder einer anderen HTTP-Client-Bibliothek.
Kehren Sie zum GET-Endpunkt zurück und erstellen Sie eine neue Datei mit dem Namen api.test.js. Hier schreiben Sie alle Endpunkttests. Benennen Sie die Testdatei mit a .Prüfung infix stellt sicher, dass Jest es als Testdatei erkennt.
Importieren Sie in api.test.js supertest und legen Sie die Basis-URL wie folgt fest:
konst Anfrage = benötigen("Supertest")
konst baseURL = "http://lokaler Host: 3000"
Erstellen Sie als Nächstes den ersten Test im Beschreibungsblock:
beschreiben("GET /todos", () => {
konst newTodo = {
Ich würde: Krypto.randomUUID(),
Artikel: "Wasser trinken",
abgeschlossen: FALSCH,
}
vor allen(asynchron () => {
// Aufgabe einrichten
warte auf Anfrage (baseURL).post("/todo").send (newTodo);
})
schließlich(asynchron () => {
erwarten Anfrage (Basis-URL).delete(`/todo/${newTodo.id}`)
})
es("sollte 200 zurückgeben", asynchron () => {
konst Antwort = erwarten Anfrage (BasisURL).get("/todos");
erwarten von(Antwort.Statuscode).sein(200);
erwarten von(Antwort.Karosserie.Error).sein(Null);
});
es("sollte todos zurückgeben", asynchron () => {
konst Antwort = erwarten Anfrage (BasisURL).get("/todos");
erwarten (response.body.data.length >= 1).sein(Stimmt);
});
});
Bevor Sie die Tests ausführen, müssen Sie Setup- und Teardown-Funktionen definieren. Diese Funktionen füllen das todo-Array vor dem Test mit einem Element und löschen die Dummy-Daten nach jedem Test.
Der Code, der vor allen Tests ausgeführt wird, befindet sich in der Funktion beforeAll(). Der Code, der nach allen Tests ausgeführt wird, befindet sich in der Funktion afterAll().
In diesem Beispiel treffen Sie einfach die POST- und DELETE-Endpunkte für jeden. In einer realen Anwendung würden Sie wahrscheinlich eine Verbindung zu einer Scheindatenbank herstellen, die die Testdaten enthält.
In diesem Test haben Sie zuerst eine Anfrage an den GET /todos-Endpunkt gestellt und die zurückgesendete Antwort mit den erwarteten Ergebnissen verglichen. Diese Testsuite wird bestanden, wenn die Antwort eine hat HTTP-Statuscode von 200, die Daten sind nicht leer und die Fehlermeldung ist null.
Testen Sie den POST /todo-Endpunkt
Erstellen Sie in index.js den Endpunkt POST /todo:
app.post("/todo", (req, res) => {
Versuchen {
konst { ID, Artikel, abgeschlossen } = req.body;
konst newTodo = {
Ich würde,
Artikel,
abgeschlossen,
};
todos.drücken(neuTodo);
Rückkehrres.Status(201).json({
Daten: todos,
Error: Null,
});
} Fang (Error) {
Rückkehrres.Status(500).json({
Daten: Null,
Fehler: Fehler,
});
}
});
In diesem Test müssen Sie die Todo-Details im Anfragetext mit der Methode send() senden.
Anfrage (Basis-URL).post("/todo").send (newTodo)
Die POST /todo-Anforderung sollte einen 201-Statuscode und das todos-Array mit dem am Ende hinzugefügten neuen Element zurückgeben. So könnte der Test aussehen:
beschreiben("POST /todo", () => {
konst newTodo = {
// machen
}
schließlich(asynchron () => {
erwarten Anfrage (Basis-URL).delete(`/todo/${newTodo.id}`)
})
es("sollte ein Element zum Todos-Array hinzufügen", asynchron () => {
konst Antwort = erwarten Anfrage (Basis-URL).post("/todo").send(newTodo);
konst lastItem = antwort.body.data[antwort.body.data.length-1]
erwarten von(Antwort.Statuscode).sein(201);
erwarten von(Letzter Artikel.Artikel).sein(neuTodo["Artikel"]);
erwarten von(Letzter Artikel.abgeschlossen).sein(neuTodo["abgeschlossen"]);
});
});
Hier übergeben Sie die Todo-Daten als Argument an die Methode send(). Die Antwort sollte einen 201-Statuscode haben und auch alle ToDo-Elemente in einem Datenobjekt enthalten. Um zu testen, ob todo tatsächlich erstellt wurde, überprüfen Sie, ob der letzte Eintrag in den zurückgegebenen todos mit dem übereinstimmt, den Sie in der Anfrage gesendet haben.
Der Endpunkt PUT /todos/:id sollte das aktualisierte Element zurückgeben:
app.put("/todos/:id", (req, res) => {
Versuchen {
konst id = req.params.id
konst todo = todos.find((todo) => todo.id == id);
if(!todo) {
WurfNeuFehler("Aufgaben nicht gefunden")
}
todo.completed = req.body.completed;
Rückkehrres.Status(201).json({
Daten: todo,
Error: Null,
});
} Fang (Error) {
Rückkehrres.Status(500).json({
Daten: Null,
Fehler: Fehler,
});
}
});
Testen Sie die Antwort wie folgt:
beschreiben("Aktualisieren Sie eine Aufgabe", () => {
konst newTodo = {
// machen
}
vor allen(asynchron () => {
warte auf Anfrage (baseURL).post("/todo").send (newTodo);
})
schließlich(asynchron () => {
erwarten Anfrage (Basis-URL).delete(`/todo/${newTodo.id}`)
})
es("sollte das Element aktualisieren, falls es vorhanden ist", asynchron () => {
konst Antwort = erwarten Anfrage (BasisURL).put(`/todos/${newTodo.id}`).senden({
abgeschlossen: Stimmt,
});
erwarten von(Antwort.Statuscode).sein(201);
erwarten von(Antwort.Karosserie.Daten.abgeschlossen).sein(Stimmt);
});
});
Der ausgefüllte Wert im Antworttext sollte wahr sein. Denken Sie daran, die ID des Elements, das Sie aktualisieren möchten, in die URL aufzunehmen.
Testen Sie den Endpunkt DELETE /todos/:id
Erstellen Sie in index.js den DELETE-Endpunkt. Es sollte die Aufgabendaten ohne das gelöschte Element zurückgeben.
app.delete("/todos/:id", (req, res) => {
Versuchen {
konst id = req.params.id
konst todo = todos[0]
wenn (todo) {
todos.spleißen(Ich würde, 1)
}
Rückkehrres.Status(200).json({
Daten: todos,
Error: Null,
});
} Fang (Error) {
Rückkehrres.Status(500).json({
Daten: Null,
Fehler: Fehler,
});
}
});
Um den Endpunkt zu testen, können Sie prüfen, ob das gelöschte Element noch in den zurückgegebenen Daten vorhanden ist:
beschreiben("Löschen Sie eine Aufgabe", () => {
konst newTodo = {
// machen
}
vor allen(asynchron () => {
warte auf Anfrage (baseURL).post("/todo").send (newTodo);
})
es("sollte ein Element löschen", asynchron () => {
konst Antwort = erwarten Anfrage (Basis-URL).delete(`/todos/${newTodo.id}`);
konst todos = antwort.body.data
konst existiert = todos.find (todo => {
newTodo.id == todoId
})
erwarten (existiert).toBe(nicht definiert)
});
});
Die vom DELETE-Endpunkt zurückgegebenen Daten sollten das gelöschte Element nicht enthalten. Da sich die zurückgegebenen Elemente in einem Array befinden, können Sie mit Array[id] überprüfen, ob die API das Element korrekt gelöscht hat. Das Ergebnis sollte falsch sein.
Erstellen von REST-APIs
In diesem Artikel haben Sie gelernt, wie Sie eine Express-Rest-API mit der Jest-API testen. Sie haben Tests für die HTTP-Anforderungen GET, PUT, POST und DELETE geschrieben und gesehen, wie Daten in der URL und der Anforderung an den Endpunkt gesendet werden. Dieses Wissen sollten Sie beim Testen Ihrer eigenen Rest-API anwenden können.
