So testen Sie Node.js REST-APIs mit Mocha, Chai und Chai-HTTP

Moderne Softwareentwicklung nutzt APIs in großem Umfang. Sie dienen als entscheidendes Bindeglied zwischen clientseitigen Anwendungen und Backend-Anwendungen sowie zwischen verschiedenen internen oder externen Apps.

APIs ermöglichen eine reibungslose Kommunikation und einen reibungslosen Datenaustausch, sodass Softwarekomponenten nahtlos miteinander interagieren können. Die Gewährleistung der Zuverlässigkeit, Funktionalität und Leistung dieser APIs ist von größter Bedeutung, um ein nahtloses Benutzererlebnis zu bieten und die Gesamtintegrität des Systems aufrechtzuerhalten.

Daher ist es wichtig, Ihre APIs gründlich zu testen, um Fehler während der Entwicklung zu erkennen und zu beheben und so mögliche Systemausfälle in Produktionsumgebungen zu verhindern.

Testen von Node.js-APIs mit Mocha, Chai und Chai-HTTP

Mokka ist ein weit verbreitetes Testframework, das mit verschiedenen kompatibel ist JavaScript-Frameworks. Eine seiner Hauptfunktionen ist ein flexibler Testläufer, der den Prozess der effektiven Verwaltung und Ausführung von Testfällen vereinfacht.

Es unterstützt außerdem verschiedene Teststile, einschließlich synchroner und asynchroner Tests, und ermöglicht so eine Vielzahl von Testszenarien.

Andererseits, Chai Und Chai-HTTP sind Assertionsbibliotheken, die Sie in Verbindung mit Mocha verwenden können. Chai bietet eine breite Palette ausdrucksstarker und lesbarer Assertionsschnittstellen wie „Should“, „Expect“ und „Assertion“. Chai-HTTP hingegen, eine Erweiterung von Chai, bietet eine Schnittstelle, die speziell zum Testen von HTTP-Anfragen und zur Bestätigung ihrer Antworten entwickelt wurde.

Durch die Verwendung von Mocha in Verbindung mit Chai und Chai-HTTP können Sie APIs effektiv testen. Der Testworkflow umfasst:

• Senden von HTTP-Anfragen an die angegebenen API-Endpunkte.
• Definieren der erwarteten Antworten.
• Validierung der empfangenen Daten von der angegebenen Quelle, der HTTP-Statuscodes und mehr.

Sie können auch API-Fehlertestszenarien simulieren, die in solchen Situationen auftreten können, und welche Aktionen in diesem Fall ausgelöst werden sollen.

Den Code dieses Projekts finden Sie in seiner GitHub-Repository.

Richten Sie das Express.js-Projekt und die MongoDB-Datenbank ein

Um zu beginnen, Erstellen Sie einen Express-Webserver, und installieren Sie diese Pakete:

npm install cors dotenv mongoose mongodb

Nächste, Erstellen Sie eine MongoDB-Datenbank oder Konfigurieren Sie einen MongoDB-Cluster in der Cloud. Kopieren Sie dann die Datenbankverbindungs-URL und erstellen Sie eine .env Datei im Stammverzeichnis und fügen Sie die Datenbankverbindungszeichenfolge ein:

CONNECTION_STRING="Verbindungszeichenfolge"

Um den Einrichtungsprozess abzuschließen, müssen Sie die Datenbankverbindung konfigurieren und die Datenmodelle für Ihre Benutzerdaten definieren. Sehen Sie sich den Code im GitHub-Repository dieses Projekts an, um Folgendes zu tun:

• Konfigurieren Sie die Datenbankverbindung in utils/db.js.
• Definieren Sie das Benutzerdatenschema in models/user.model.js.

Definieren Sie die Handler-Funktionen für die API-Routen

Die Controller-Funktionen verwalten das Hinzufügen und Abrufen von Benutzerdaten in der Datenbank. Um die Funktionalität dieser Handlerfunktionen sicherzustellen, testen Sie, ob sie erfolgreich Daten aus der Datenbank veröffentlichen und abrufen können.

Erstellen Sie im Stammverzeichnis eine controllers/userControllers.js Datei und fügen Sie den folgenden Code hinzu:

const Benutzer = erfordern('../models/user.model');
exports.registerUser = asynchron (req, res) => {
const { Benutzername, Passwort } = req.body;
versuchen {
erwarten User.create({ Benutzername, Passwort});
 res.status(201).schicken({ Nachricht: „Benutzer erfolgreich registriert“ });
 } fangen (Fehler) {
Konsole.log (Fehler);
 res.status(500).schicken({ Nachricht: 'Ein Fehler ist aufgetreten!! ' });
 }
};
exports.getUsers = asynchron (req, res) => {
versuchen {
const Benutzer = erwarten User.find({});
 res.json (Benutzer);
 } fangen (Fehler) {
Konsole.log (Fehler);
 res.status(500).schicken({ Nachricht: 'Ein Fehler ist aufgetreten!!' });
 }
};

Definieren Sie die API-Routen

Erstelle eine neue Routen/userRoutes.js Datei im Stammverzeichnis und fügen Sie den folgenden Code hinzu.

const ausdrücken = erfordern('äußern');
const Router = Express. Router();
const userControllers = erfordern('../controllers/userControllers');
router.post('/api/register', userControllers.registerUser);
router.get('/api/users', userControllers.getUsers);
Modul.exports = Router;

Definieren Sie Ihren Server-Einstiegspunkt

Aktualisieren Sie Ihre server.js Datei mit dem folgenden Code.

const ausdrücken = erfordern('äußern');
const cors = erfordern('Cors');
const app = express();
const Port = 5000;
erfordern('dotenv').config();
const connectDB = erfordern('./utils/db');
connectDB();
app.use (express.json());
app.use (express.urlencoded({ erweitert: WAHR }));
app.use (cors());
const userRoutes = erfordern('./routes/userRoutes');
app.use('/', userRoutes);
app.listen (port, () => {
Konsole.Protokoll(„Server lauscht http://localhost:${port}`);
});
Modul.exports = app;

Schreiben und führen Sie die Testfälle mit Mocha aus

Sobald die Benutzer-API eingerichtet ist, können Sie mit der Konfiguration der Testumgebung fortfahren. Installieren Sie diese Pakete zunächst als Entwicklungsabhängigkeiten.

npm install mocha chai chai-http --save-dev

Fügen Sie nun das folgende Skript zu Ihrer package.json-Datei hinzu.

„Skripte“: {
"prüfen": „mocha --timeout 10000“
},

Dieser Befehl führt die Testfälle aus. Durch Hinzufügen der Timeout-Eigenschaft mit einem geeigneten Wert können Sie die maximal zulässige Zeit für die Ausführung einzelner Testfälle steuern.

Dies kann nützlich sein, um zu verhindern, dass Tests auf unbestimmte Zeit ausgeführt werden oder zu schnell abgeschlossen werden, bevor die Testfälle abgeschlossen sind.

Testen Sie die API-Endpunkte

Erstellen Sie im Stammverzeichnis einen neuen Ordner und benennen Sie ihn prüfen. Erstellen Sie in diesem Ordner einen neuen user.tests.js Datei und fügen Sie den folgenden Code für den POST-Endpunkt-Testfall hinzu.

const chai = erfordern('Chai');
const chaiHttp = erfordern('chai-http');
const app = erfordern('../Server'); 
chai.use (chaiHttp);
const erwarten = chai.expect;
beschreiben('Benutzer-API', () => {
 beschreiben('POST /api/register', () => {
 Es('sollte die Benutzerregistrierung übernehmen', (erledigt) => {
 chai.request (App)
 .Post('/api/register')
 .schicken({ Nutzername: 'testUser', Passwort: 'Testpasswort' })
 .Ende((ähm, res) => {
Wenn (irren) {
 erwarten (res).to.have.status(500);
 erwarten (res.body).to.have.property('Nachricht').das.ist.gleich('Ein Fehler ist aufgetreten!!');
 } anders {
 erwarten (res).to.have.status(201);
 erwarten (res.body).to.have.property('Nachricht').gleich(„Benutzer erfolgreich registriert“);
 }
 Erledigt();
 });
 });
 });
});

Dieser Code definiert einen Testfall mit Chai und Chai HTTP, um die Benutzerregistrierungsfunktionalität der Benutzer-API zu testen.

Es sendet eine POST-Anfrage an den angegebenen Endpunkt und macht Aussagen über die erwartete API-Antwort, um zu überprüfen, ob die Benutzerregistrierungsfunktion erfolgreich war oder ob ein Fehler aufgetreten ist.

Hier ist eine Aufschlüsselung der Hauptkomponenten des Testfalls:

• erwarten – Mit diesem Objekt können Sie die Chai-Assertionsmethoden verwenden, um Aussagen über die erwartete Antwort von der API zu treffen.
• beschreiben - Es beschreibt zusammengehörige Testfälle, in diesem Fall Tests im Zusammenhang mit Benutzer-API. Der verschachtelte Beschreibungsblock gruppiert weitere zusammengehörige Testfälle, in diesem Fall die POST /api/register. Dies hilft, die Testfälle speziell für eine bestimmte Funktionalität zu organisieren.
• Es – Diese Funktion beschreibt das erwartete Verhalten des API-Endpunkts.
• Ende – Diese Funktion sendet die Anfrage und stellt eine Rückruffunktion zur Verarbeitung der Antwort bereit. Die Callback-Funktion führt Behauptungen mithilfe von aus erwarten Funktion zum Überprüfen der von der API empfangenen Antwort.
• Erledigt – Diese Funktion wird ausgeführt, um das Ende des Testfalls zu markieren.

Fügen Sie abschließend den Code für den GET-Endpunkttestfall direkt nach dem POST-Endpunkttestfall hinzu.

beschreiben('GET /api/users', () => {
 Es('sollte alle Benutzerdaten abrufen', (erledigt) => {
 chai.request (App)
 .erhalten('/api/users')
 .Ende((ähm, res) => {
Wenn (irren) {
 erwarten (res).to.have.status(500);
 erwarten (res.body).to.have.property('Nachricht').das.ist.gleich(„Beim Abrufen der Benutzerdaten ist ein Fehler aufgetreten“);
 } anders {
 erwarten (res).to.have.status(200);
 erwarten (res.body).to.be.an('Array');
 }
 Erledigt();
 });
 });
});

Fahren Sie fort und führen Sie das Testskript auf Ihrem Terminal aus, um die beiden Testfälle auszuführen.

NPM-Test

Wenn bei der Ausführung der Testfälle keine Fehler auftreten, sollten Sie eine ähnliche Ausgabe sehen, die darauf hinweist, dass die Tests erfolgreich bestanden wurden.

Testfehler können aus verschiedenen Gründen auftreten, z. B. aufgrund von Netzwerkkonnektivitätsproblemen bei HTTP-Anfragen an die Datenbank, fehlenden erforderlichen Daten, logischen Fehlern und anderen Problemen.

Mocha leistet gute Arbeit bei der Identifizierung und Hervorhebung solcher Fehler und stellt klare und detaillierte Testberichte in den im Terminalfenster angezeigten Protokollen bereit. Auf diese Weise können Sie die spezifischen Probleme, die zu Testfehlern geführt haben, einfach identifizieren und diagnostizieren.

Mocha gibt Ihnen keine Entschuldigung, Ihre APIs nicht zu testen

Das manuelle Testen der Funktionalität Ihrer APIs mithilfe von Tools wie Postman ist ein gültiger Test Der Ansatz, der Mocha und andere Test-Frameworks für automatisierte Tests nutzt, geht auf die nächste Stufe eben.

Mit diesen Testtools können Sie Tests schnell und einfach automatisieren, um ein breites Spektrum an Szenarien und Randfällen abzudecken. Dadurch können Sie Fehler schnell erkennen und beheben, bevor Sie Ihre APIs bereitstellen, und so sicherstellen, dass Sie qualitativ hochwertige Software in die Produktion bringen.