Es kann eine Herausforderung sein, Mongoose-Modelle zu testen, da Sie Tests schreiben müssen, die Ihre eigentliche Datenbank nicht beeinträchtigen. Das MongoDB-Memory-Server-Paket bietet eine unkomplizierte Lösung. Damit können Sie Ihre Testdaten im Anwendungsspeicher speichern.
In diesem Lernprogramm erstellen Sie ein einfaches Mongoose-Modell und schreiben Tests mit Jest und dem MongoDB-Speicherserver.
Was ist MongoDB Memory Server?
Das Letzte, was Sie wollen, ist, gefälschte Daten in Ihrer echten Datenbank zu speichern, was passieren könnte, wenn Sie sich während des Tests mit ihr verbinden. Stattdessen können Sie sich dafür entscheiden, eine separate lokale MongoDB-Instanz zum Speichern Ihrer Daten zu verwenden. Dies funktioniert zwar, ist aber nicht machbar, wenn Ihre Tests in der Cloud ausgeführt werden. Darüber hinaus kann das Verbinden und Abfragen einer echten Datenbank während jedes Tests teuer werden.
MongoDB-Speicherserver, startet jedoch einen echten MongoDB-Server und ermöglicht es Ihnen, die Testdaten im Arbeitsspeicher zu speichern. Dies ist schneller als die Verwendung einer lokalen MongoDB-Datenbank, da Daten nicht auf eine physische Festplatte geschrieben werden.
Erstellen des Mongoose-Modells
Mongoose-Modelle bieten eine Schnittstelle für die Verbindung mit der MongoDB-Datenbank. Um sie zu erstellen, müssen Sie sie aus einem Mongoose-Schema kompilieren, die Ihr MongoDB-Datenmodell definiert. In diesem Lernprogramm wird ein Schema für ein Aufgabendokument verwendet. Es enthält den Titel und ausgefüllte Felder.
Führen Sie den folgenden Befehl im Terminal aus, um einen neuen Ordner zu erstellen und zu ihm zu navigieren.
mkdir Mungo-Modell-Test
CD Mungo-Modell-Test
Initialisieren Sie npm mit dem folgenden Befehl:
npm init -y
Das -y flag weist npm an, eine package.json-Datei mit Standardwerten zu generieren.
Führen Sie diesen Befehl aus, um die zu installieren Mungo Paket:
npm Installieren Mungo
Erstellen Sie eine neue Datei mit dem Namen todo.model.js und definieren Sie das Todo-Schema:
konst Mungo = benötigen("Mungo")
konst { Schema } = Mungo
konst TodoSchema = Neu Schema({
Artikel: {
Typ: Schnur,
erforderlich: Stimmt
},
abgeschlossen: {
Typ: Boolesch,
erforderlich: Stimmt
}
})
Erstellen und exportieren Sie am Ende dieser Datei das Todo-Modell:
Modul.Exporte = mongoose.model("Todo", TodoSchema)
Planung der Tests
Wenn Sie Tests schreiben, möchten Sie im Voraus planen, was Sie testen werden. Dadurch wird sichergestellt, dass Sie alle Funktionen Ihres Modells testen.
Nach dem von uns erstellten Mongoose-Modell sollte das Todo ein Element vom Typ String und ein ausgefülltes Feld vom Typ Boolean enthalten. Beide Felder sind erforderlich. Das bedeutet, dass unser Test mindestens Folgendes sicherstellen sollte:
- Gültige Artikel wurden erfolgreich in der Datenbank gespeichert.
- Artikel ohne erforderliche Felder werden nicht gespeichert.
- Elemente mit Feldern ungültigen Typs werden nicht gespeichert.
Wir werden diese Tests in einem Testblock schreiben, da sie zusammenhängen. In Jest definieren Sie diesen Testblock mit der beschreiben Funktion. Zum Beispiel:
beschreiben('Todo-Modelltest', () => {
// Deine Tests kommen hierher
}
Einrichten der Datenbank
Um einen MongoDB-Speicherserver einzurichten, erstellen Sie eine neue Mongo-Speicherserverinstanz und stellen eine Verbindung zu Mongoose her. Sie werden auch Funktionen erstellen, die dafür verantwortlich sind, alle Sammlungen in der Datenbank zu löschen und die Verbindung zur Mongo-Speicherserverinstanz zu trennen.
Führen Sie zur Installation den folgenden Befehl aus mongodb-Speicherserver.
npm Installieren mongodb-Erinnerung-Server
Erstellen Sie eine neue Datei mit dem Namen setuptestdb.js und importieren Sie Mongoose und Mongodb-Memory-Server.
konst Mungo = benötigen("Mungo");
konst { MongoMemoryServer } = benötigen("mongodb-Speicherserver");
Erstellen Sie als Nächstes eine Funktion connectDB(). Diese Funktion erstellt eine neue Mongo-Speicherserverinstanz und stellt eine Verbindung zu Mongoose her. Sie führen es vor allen Tests aus, um eine Verbindung zur Testdatenbank herzustellen.
Lassen Mongo = Null;konst connectDB = asynchron () => {
Mongo = erwarten MongoMemoryServer.create();
konst uri = mongo.getUri();
erwarten mungo.connect (uri, {
useNewUrlParser: Stimmt,
useUnifiedTopology: Stimmt,
});
};
Erstellen Sie eine dropDB()-Funktion, indem Sie den folgenden Code hinzufügen. Diese Funktion löscht die Datenbank, schließt die Mongoose-Verbindung und stoppt die Mongo-Speicherserverinstanz. Sie führen diese Funktion aus, nachdem alle Tests ausgeführt wurden.
konst dropDB = asynchron () => {
wenn (mongo) {
erwartenMungo.Verbindung.dropDatenbank();
erwartenMungo.Verbindung.nah dran();
erwarten mongo.stop();
}
};
Die letzte Funktion, die Sie erstellen, heißt dropCollections(). Es lässt alle erstellten Mongoose-Sammlungen fallen. Sie werden es nach jedem Test ausführen.
konst dropCollections = asynchron () => {
wenn (mongo) {
konst Sammlungen = erwarten mongoose.connection.db.collections();
zum (Lassen Sammlung von Sammlungen) {
erwarten Sammlung.Entfernen ();
}
}
};
Exportieren Sie schließlich die Funktionen conenctDB(), dropDB() und dropCollections().
Modul.Exporte = {connectDB, dropDB, dropCollections}
Schreiben der Tests
Wie bereits erwähnt, verwenden Sie Jest, um die Tests zu schreiben. Führen Sie den folgenden Befehl aus, um Jest zu installieren.
npm Installieren Scherz
In dem Paket.json Datei, jest konfigurieren. Ersetzen Sie Ihren vorhandenen "Skripts"-Block durch Folgendes:
"Skripte": {
"Prüfung": "Spaß --runInBand --detectOpenHandles"
},
"Scherz": {
"Test Umgebung": "Knoten"
},
Erstellen Sie eine neue Datei mit dem Namen todo.model.test.js und importieren Sie die Mongoose-Bibliothek, das Todo-Modell und die Funktionen conenctDB(), dropDB() und dropCollections():
konst Mungo = benötigen("Mungo");
konst {connectDB, dropDB, dropCollections} = benötigen("./setupdb");
konst Todo = benötigen("./todo.model");
Sie müssen die Funktion connectDB() ausführen, bevor alle Tests ausgeführt werden. Mit Jest können Sie die Methode beforeAll() verwenden.
Sie müssen auch Bereinigungsfunktionen ausführen. Führen Sie nach jedem Test die dropCollections()-Funktion und die dropDB()-Funktion nach allen Tests aus. Sie müssen dies nicht manuell tun und können die Methoden afterEach() und afterAll() von Jest verwenden.
Fügen Sie den folgenden Code zur Datei todo.model.test.js hinzu, um die Datenbank einzurichten und zu bereinigen.
vor allen(asynchron () => {
erwarten connectDB();
});schließlich(asynchron () => {
erwarten dropDB();
});
nach jedem(asynchron () => {
erwarten dropCollections();
});
Sie können jetzt die Tests erstellen.
Der erste Test prüft, ob das Todo-Element erfolgreich in die Datenbank eingefügt wurde. Es wird überprüft, ob die Objekt-ID im erstellten to vorhanden ist und ob die darin enthaltenen Daten mit denen übereinstimmen, die Sie an die Datenbank gesendet haben.
Erstellen Sie einen Beschreibungsblock und fügen Sie den folgenden Code hinzu.
beschreiben("Todo-Modell", () => {
es("sollte erfolgreich ein Aufgabenelement erstellen", asynchron () => {
Lassen validTodo = {
Artikel: "das Geschirr spülen",
abgeschlossen: FALSCH,
};
konst newTodo = erwarten Todo (validTodo);
erwarten newTodo.save();
erwarten von(neuTodo._Ich würde).zu definieren();
erwarten von(neuTodo.Artikel).sein(validTodo.Artikel);
erwarten von(neuTodo.abgeschlossen).sein(validTodo.abgeschlossen);
});
});
Dies erstellt ein neues Dokument in der Datenbank enthält die Daten in der validTodo-Variablen. Das zurückgegebene Objekt wird dann anhand der erwarteten Werte validiert. Damit dieser Test bestanden wird, sollte der zurückgegebene Wert eine Objekt-ID haben. Außerdem sollten die Werte in den Feldern „item“ und „complete“ mit denen im validTodo-Objekt übereinstimmen.
Neben dem Testen des normalen Anwendungsfalls müssen Sie auch einen fehlgeschlagenen Anwendungsfall testen. Aus den von uns geplanten Tests müssen Sie das Mongoose-Modell mit einem Aufgabenobjekt testen, mit einem fehlenden erforderlichen Feld und einem mit einem falschen Typ.
Fügen Sie wie folgt einen zweiten Test zu demselben Beschreibungsblock hinzu:
es("sollte für Todo-Elemente ohne erforderliche Felder fehlschlagen", asynchron () => {
Lassen ungültigTodo = {
Artikel: "das Geschirr spülen",
};
Versuchen {
konst newTodo = Neu Todo (invalidTodo);
erwarten newTodo.save();
} Fang (Error) {
erwarten von(Error).toBeInstanceOf(Mungo.Fehler.Validierungsfehler);
erwarten von(Error.Fehler.abgeschlossen).zu definieren();
}
});
Das Todo-Mongoose-Modell erwartet sowohl das Element als auch ausgefüllte Felder. Es sollte einen Fehler ausgeben, wenn Sie versuchen, eine Aufgabe ohne eines dieser Felder zu speichern. Dieser Test verwendet den try…catch-Block, um den ausgelösten Fehler abzufangen. Der Test erwartet, dass die Fehler ein Mongoose-Validierungsfehler sind und aus dem fehlenden ausgefüllten Feld stammen.
Um zu testen, ob das Modell einen Fehler auslöst, wenn Sie Werte des falschen Typs verwenden, fügen Sie den folgenden Code zum Beschreibungsblock hinzu.
es("sollte für Aufgabenelemente mit Feldern des falschen Typs fehlschlagen", asynchron () => {
Lassen ungültigTodo = {
Artikel: "das Geschirr spülen",
abgeschlossen: "FALSCH"
};
Versuchen {
konst newTodo = Neu Todo (invalidTodo);
erwarten newTodo.save();
} Fang (Error) {
erwarten von(Error).toBeInstanceOf(Mungo.Fehler.Validierungsfehler);
erwarten von(Error.Fehler.abgeschlossen).zu definieren();
}
});
Beachten Sie, dass der Wert des ausgefüllten Felds eine Zeichenfolge anstelle eines booleschen Werts ist. Der Test erwartet, dass ein Validierungsfehler ausgelöst wird, da das Modell einen booleschen Wert erwartet.
MongoMemoryServer und Jest bilden ein großartiges Team
Das npm-Paket mongo-memory-server bietet eine einfache Lösung zum Testen von Mongoose-Modellen. Sie können Dummy-Daten im Speicher speichern, ohne die Datenbank Ihrer Anwendung zu berühren.
Sie können MongoMemoryServer mit Jest verwenden, um Tests für Mongoose-Modelle zu schreiben. Beachten Sie, dass es nicht alle möglichen Tests abdeckt, die Sie für Ihre Modelle schreiben können. Diese Tests hängen von Ihrem Schema ab.