Testování modelů Mongoose může být náročné, protože musíte psát testy, které nezasahují do vaší skutečné databáze. Balíček paměťového serveru MongoDB nabízí jednoduché řešení. Umožňuje vám ukládat testovací data do paměti aplikace.
V tomto tutoriálu vytvoříte jednoduchý model Mongoose a napíšete testy pomocí Jest a paměťového serveru MongoDB.
Co je paměťový server MongoDB?
Poslední věc, kterou chcete, je uložit falešná data do vaší skutečné databáze, což se může stát, pokud se k ní připojíte během testování. Místo toho se můžete rozhodnout použít samostatnou místní instanci MongoDB k ukládání dat. I když to funguje, je to neproveditelné, pokud vaše testy běží v cloudu. Navíc připojení a dotazování na skutečnou databázi během každého testu může být drahé.
Paměťový server MongoDB, nicméně spustí skutečný MongoDB server a umožní vám uložit testovací data do paměti. Díky tomu je to rychlejší než použití místní databáze MongoDB, protože data nejsou zapisována na fyzický disk.
Vytvoření modelu Mongoose
Modely Mongoose poskytují rozhraní pro propojení s databází MongoDB. Chcete-li je vytvořit, musíte je zkompilovat ze schématu Mongoose, který definuje váš datový model MongoDB. Tento výukový program bude používat schéma pro dokument úkolu. Bude obsahovat název a vyplněná pole.
Spuštěním následujícího příkazu v terminálu vytvořte novou složku a přejděte do ní.
mkdir mongoose-model-test
CD mangoose-model-test
Inicializujte npm pomocí následujícího příkazu:
npm init -y
The -y flag dává pokyn npm, aby vygeneroval soubor package.json s výchozími hodnotami.
Provedením tohoto příkazu nainstalujte mangusta balík:
npm Nainstalujte mangusta
Vytvořte nový soubor s názvem todo.model.js a definujte schéma úkolu:
konst mangusta = vyžadovat("mangusta")
konst { Schéma } = mangusta
konst TodoSchema = Nový Schéma({
položka: {
typ: Tětiva,
Požadované: skutečný
},
dokončeno: {
typ: Boolean,
Požadované: skutečný
}
})
Na konci tohoto souboru vytvořte a exportujte model úkolu:
modul.exportů = mongoose.model("Todo", TodoSchema)
Plánování testů
Při psaní testů si chcete předem naplánovat, co budete testovat. To zajišťuje, že testujete všechny funkce svého modelu.
Z námi vytvořeného modelu Mongoose by úkol měl obsahovat položku typu String a vyplněné pole typu Boolean. Obě tato pole jsou povinná. To znamená, že náš test by měl minimálně zajistit:
- Platné položky jsou úspěšně uloženy do databáze.
- Položky bez povinných polí se neuloží.
- Položky s poli neplatného typu se neuloží.
Tyto testy napíšeme do jednoho testovacího bloku, protože spolu souvisí. V Jest definujete tento testovací blok pomocí popsat funkce. Například:
popsat('Test modelu Todo', () => {
// Vaše testy jsou zde
}
Nastavení databáze
Chcete-li nastavit paměťový server MongoDB, vytvořte novou instanci paměťového serveru Mongo a připojte se k Mongoose. Vytvoříte také funkce, které budou zodpovědné za odstranění všech kolekcí v databázi a odpojení od instance paměťového serveru Mongo.
Pro instalaci spusťte následující příkaz mongodb-memory-server.
npm Nainstalujte mongodb-Paměť-server
Vytvořte nový soubor s názvem setuptestdb.js a importujte mongoose a mongodb-memory-server.
konst mangusta = vyžadovat("mangusta");
konst { MongoMemoryServer } = vyžadovat("mongodb-memory-server");
Dále vytvořte funkci connectDB(). Tato funkce vytvoří novou instanci paměťového serveru Mongo a připojí se k Mongoose. Spustíte jej před všemi testy pro připojení k testovací databázi.
nechat mongo = nula;konst connectDB = asynchronní () => {
mongo = čekat MongoMemoryServer.create();
konst uri = mongo.getUri();
čekat mongoose.connect (uri, {
useNewUrlParser: skutečný,
useUnifiedTopology: skutečný,
});
};
Vytvořte funkci dropDB() přidáním následujícího kódu. Tato funkce zruší databázi, zavře připojení Mongoose a zastaví instanci paměťového serveru Mongo. Tuto funkci spustíte po dokončení všech testů.
konst dropDB = asynchronní () => {
if (mongo) {
čekatmangusta.spojení.dropDatabase();
čekatmangusta.spojení.zavřít();
čekat mongo.stop();
}
};
Poslední funkce, kterou vytvoříte, se nazývá dropCollections(). Zahodí všechny vytvořené kolekce Mongoose. Spustíte jej po každém testu.
konst dropCollections = asynchronní () => {
if (mongo) {
konst sbírky = čekat mongoose.connection.db.collections();
pro (nechat sbírka z sbírky) {
čekat collection.remove();
}
}
};
Nakonec exportujte funkce conenctDB(), dropDB() a dropCollections().
modul.exportů = { connectDB, dropDB, dropCollections}
Psaní testů
Jak již bylo zmíněno, k psaní testů budete používat Jest. Spuštěním následujícího příkazu nainstalujte jest.
npm Nainstalujte žert
V package.json soubor, konfigurovat jest. Nahraďte stávající blok „scripts“ následujícím:
"skripty": {
"test": "jest --runInBand --detectOpenHandles"
},
"žert": {
"testovací prostředí": "uzel"
},
Vytvořte nový soubor s názvem todo.model.test.js a importujte knihovnu mongoose, model úkolů a funkce conenctDB(), dropDB() a dropCollections():
konst mangusta = vyžadovat("mangusta");
konst { connectDB, dropDB, dropCollections } = vyžadovat(./setupdb");
konst Todo = vyžadovat(./todo.model");
Před spuštěním všech testů musíte spustit funkci connectDB(). S Jest můžete použít metodu beforeAll().
Musíte také spustit funkce čištění. Po každém testu spusťte funkci dropCollections() a funkci dropDB() po všech testech. Nemusíte to dělat ručně a můžete použít metody afterEach() a afterAll() z Jest.
Přidejte následující kód do souboru todo.model.test.js pro nastavení a vyčištění databáze.
předtímVše(asynchronní () => {
čekat connectDB();
});po všem(asynchronní () => {
čekat dropDB();
});
po každém (asynchronní () => {
čekat dropCollections();
});
Nyní jste připraveni vytvořit testy.
První test zkontroluje, zda byla položka úkolu úspěšně vložena do databáze. Zkontroluje, zda je ID objektu přítomno ve vytvořeném do a zda data v něm odpovídají datům, které jste odeslali do databáze.
Vytvořte blok popisu a přidejte následující kód.
popsat("Model Todo", () => {
to("by měl úspěšně vytvořit položku úkolu", async () => {
nechat validTodo = {
položka: "Umýt nádobí",
dokončeno: Nepravdivé,
};
konst newTodo = čekat Todo (validTodo);
čekat newTodo.save();
očekávat(newTodo._id).být definován();
očekávat(newTodo.položka).být(validTodo.položka);
očekávat(newTodo.dokončeno).být(validTodo.dokončeno);
});
});
Tento vytvoří nový dokument v databázi obsahující data v proměnné validTodo. Vrácený objekt je poté ověřen oproti očekávaným hodnotám. Aby tento test prošel, vrácená hodnota by měla mít ID objektu. Hodnoty v polích item a Completed by se také měly shodovat s hodnotami v objektu validTodo.
Kromě testování běžného případu použití musíte také otestovat případ použití, který selhal. Z testů, které jsme naplánovali, musíte otestovat model mongoose s objektem úkolu, s chybějícím povinným polem a jedním s nesprávným typem.
Přidejte druhý test do stejného bloku popisu následovně:
to("by měl selhat u položky úkolu bez povinných polí", async () => {
nechat invalidTodo = {
položka: "Umýt nádobí",
};
Snaž se {
konst newTodo = Nový Todo (invalidTodo);
čekat newTodo.save();
} úlovek (chyba) {
očekávat(chyba).toBeInstanceOf(mangusta.Chyba.Chyba ověření);
očekávat(chyba.chyby.dokončeno).být definován();
}
});
Model Todo mongoose očekává položky i vyplněná pole. Pokud se pokusíte uložit úkol bez jednoho z těchto polí, mělo by to vyvolat chybu. Tento test používá blok try...catch k zachycení vyvolané chyby. Test očekává, že chyby budou chybou ověření mongoose a pocházejí z chybějícího vyplněného pole.
Chcete-li otestovat, zda model vyvolá chybu, pokud použijete hodnoty nesprávného typu, přidejte do bloku popisu následující kód.
to("by měl selhat u položky úkolu s poli nesprávného typu", async () => {
nechat invalidTodo = {
položka: "Umýt nádobí",
dokončeno: "Nepravdivé"
};
Snaž se {
konst newTodo = Nový Todo (invalidTodo);
čekat newTodo.save();
} úlovek (chyba) {
očekávat(chyba).toBeInstanceOf(mangusta.Chyba.Chyba ověření);
očekávat(chyba.chyby.dokončeno).být definován();
}
});
Všimněte si, že hodnota vyplněného pole je řetězec namísto booleovské hodnoty. Test očekává vyvolání chyby ověření, protože model očekává booleovskou hodnotu.
MongoMemoryServer a Jest tvoří skvělý tým
Balíček mongo-memory-server npm poskytuje snadné řešení pro testování modelů Mongoose. Falešná data můžete uložit do paměti, aniž byste se dotkli databáze aplikace.
MongoMemoryServer s Jest můžete použít k psaní testů pro modely Mongoose. Všimněte si, že nepokrývá všechny možné testy, které můžete napsat pro své modely. Tyto testy budou záviset na vašem schématu.
