Det kan vara en utmaning att testa Mongoose-modeller eftersom du behöver skriva tester som inte stör din faktiska databas. MongoDB-minnesserverpaketet erbjuder en enkel lösning. Den låter dig lagra dina testdata i applikationsminnet.
I den här handledningen kommer du att skapa en enkel Mongoose-modell och skriva tester med Jest och MongoDB-minnesservern.
Vad är MongoDB Memory Server?
Det sista du vill är att spara falska data i din riktiga databas, vilket kan hända om du ansluter till den under testningen. Istället kan du välja att använda en separat lokal MongoDB-instans för att lagra dina data. Även om detta fungerar är det omöjligt om dina tester körs på molnet. Dessutom kan det bli dyrt att ansluta och söka efter en riktig databas under varje test.
MongoDB minnesserver, däremot snurrar upp en riktig MongoDB-server och låter dig lagra testdata i minnet. Detta gör det snabbare än att använda en lokal MongoDB-databas eftersom data inte skrivs på en fysisk disk.
Skapar Mongoose-modellen
Mongoose-modeller tillhandahåller ett gränssnitt för gränssnitt med MongoDB-databasen. För att skapa dem måste du kompilera dem från ett Mongoose-schema,
som definierar din MongoDB-datamodell. Denna handledning kommer att använda ett schema för ett att göra-dokument. Den kommer att innehålla titeln och ifyllda fält.Kör följande kommando i terminalen för att skapa en ny mapp och navigera till den.
mkdir mongoose-model-test
CD mongoose-modell-test
Initiera npm med följande kommando:
npm init -y
De -y flaggan instruerar npm att generera en package.json-fil med standardvärden.
Kör det här kommandot för att installera mungo paket:
npm Installera mungo
Skapa en ny fil som heter todo.model.js och definiera att göra-schemat:
konst mangust = behöva("mungo")
konst { Schema } = mangust
konst TodoSchema = ny Schema({
Artikel: {
typ: Sträng,
nödvändig: Sann
},
genomfört: {
typ: Boolean,
nödvändig: Sann
}
})
I slutet av den här filen skapar och exporterar du att göra-modellen:
modul.export = mongoose.model("Todo", TodoSchema)
Planera testerna
När du skriver prov vill du planera vad du ska testa i förväg. Detta säkerställer att du testar all funktionalitet hos din modell.
Från Mongoose-modellen vi skapade, bör uppgiften innehålla ett objekt av typen String och ett ifyllt fält av typen Boolean. Båda dessa fält är obligatoriska. Detta innebär att vårt test åtminstone bör säkerställa:
- Giltiga objekt har sparats i databasen.
- Objekt utan obligatoriska fält sparas inte.
- Objekt med fält av ogiltig typ sparas inte.
Vi kommer att skriva dessa tester i ett testblock eftersom de är relaterade. I Jest definierar du detta testblock med hjälp av beskriva fungera. Till exempel:
beskriva('Todo modelltest', () => {
// Dina tester går här
}
Konfigurera databasen
För att ställa in en MongoDB-minnesserver, kommer du att skapa en ny Mongo-minnesserverinstans och ansluta till Mongoose. Du kommer också att skapa funktioner som kommer att ansvara för att ta bort alla samlingar i databasen och koppla från Mongo-minnesserverinstansen.
Kör följande kommando för att installera mongodb-minne-server.
npm Installera mongodb-minne-server
Skapa en ny fil som heter setuptestdb.js och importera mongoose och mongodb-memory-server.
konst mangust = behöva("mungo");
konst { MongoMemoryServer } = behöva("mongodb-minnesserver");
Skapa sedan en connectDB()-funktion. Denna funktion skapar en ny Mongo-minnesserverinstans och ansluter till Mongoose. Du kommer att köra det före alla tester för att ansluta till testdatabasen.
låta mongo = null;konst connectDB = asynkron () => {
mongo = vänta MongoMemoryServer.create();
konst uri = mongo.getUri();
vänta mongoose.connect (uri, {
useNewUrlParser: Sann,
använd UnifiedTopology: Sann,
});
};
Skapa en dropDB()-funktion genom att lägga till följande kod. Denna funktion tar bort databasen, stänger Mongoose-anslutningen och stoppar Mongo-minnesserverinstansen. Du kommer att köra den här funktionen efter att alla tester har körts färdigt.
konst dropDB = asynkron () => {
if (mongo) {
väntamungo.förbindelse.dropDatabase();
väntamungo.förbindelse.stänga();
vänta mongo.stop();
}
};
Den sista funktionen du kommer att skapa kallas dropCollections(). Det tar bort alla skapade Mongoose-samlingar. Du kommer att köra det efter varje test.
konst dropCollections = asynkron () => {
if (mongo) {
konst samlingar = vänta mongoose.connection.db.collections();
för (låta samling av samlingar) {
vänta collection.remove();
}
}
};
Exportera slutligen funktionerna conenctDB(), dropDB() och dropCollections().
modul.export = { connectDB, dropDB, dropCollections}
Att skriva proven
Som sagt kommer du att använda Jest för att skriva proven. Kör följande kommando för att installera jest.
npm Installera skoj
I den package.json fil, konfigurera skämt. Ersätt ditt befintliga "skript"-block med följande:
"skript": {
"testa": "jest --runInBand --detectOpenHandles"
},
"skoj": {
"testmiljö": "nod"
},
Skapa en ny fil som heter todo.model.test.js och importera mongoose-biblioteket, todo-modellen och funktionerna conenctDB(), dropDB() och dropCollections():
konst mangust = behöva("mungo");
konst { connectDB, dropDB, dropCollections } = behöva("./setupdb");
konst Att göra = behöva("./todo.model");
Du måste köra funktionen connectDB() innan alla tester körs. Med Jest kan du använda metoden beforeAll() .
Du måste också köra rensningsfunktioner. Efter varje test kör du dropCollections()-funktionen och dropDB()-funktionen efter alla tester. Du behöver inte göra detta manuellt och kan använda metoderna afterEach() och afterAll() från Jest.
Lägg till följande kod i filen todo.model.test.js för att ställa in och rensa databasen.
föreAlla(asynkron () => {
vänta connectDB();
});trots allt(asynkron () => {
vänta dropDB();
});
efter varje(asynkron () => {
vänta dropCollections();
});
Du är nu redo att skapa testerna.
Det första testet kommer att kontrollera om uppgiftsobjektet har infogats i databasen. Den kommer att kontrollera om objektets ID finns i den skapade till och om data däri matchar den du skickade till databasen.
Skapa ett beskrivningsblock och lägg till följande kod.
beskriva("Todo modell", () => {
Det("bör skapa ett att göra-objekt", asynkron () => {
låta validTodo = {
Artikel: "Diska",
avslutad: falsk,
};
konst newTodo = vänta Todo (validTodo);
vänta newTodo.save();
förvänta(newTodo._id).att definieras();
förvänta(newTodo.Artikel).att vara(validTodo.Artikel);
förvänta(newTodo.avslutad).att vara(validTodo.avslutad);
});
});
Detta skapar ett nytt dokument i databasen som innehåller data i variabeln validTodo. Det returnerade objektet valideras sedan mot de förväntade värdena. För att detta test ska klara måste det returnerade värdet ha ett objekt-ID. Värdena i objektet och ifyllda fält bör också matcha dem i validTodo-objektet.
Förutom att testa det normala användningsfallet måste du också testa ett misslyckat användningsfall. Från de tester vi planerade måste du testa mongoose-modellen med ett att göra-objekt, med ett obligatoriskt fält som saknas och ett med en felaktig typ.
Lägg till ett andra test till samma beskrivningsblock, enligt följande:
Det("ska misslyckas för att göra-objekt utan obligatoriska fält", asynkron () => {
låta invalidTodo = {
Artikel: "Diska",
};
Prova {
konst newTodo = ny Att göra (ogiltig Att göra);
vänta newTodo.save();
} fånga (fel) {
förvänta(fel).toBeInstanceOf(mungo.Fel.Valideringsfel);
förvänta(fel.fel.avslutad).att definieras();
}
});
Todo mongoose-modellen förväntar sig både artikeln och ifyllda fält. Det bör ge ett felmeddelande om du försöker spara en uppgift utan något av dessa fält. Det här testet använder blocket try...catch för att fånga felet. Testet förväntar sig att felen är ett valideringsfel för mangust och härrör från det saknade ifyllda fältet.
För att testa om modellen ger ett fel om du använder värden av fel typ, lägg till följande kod i describe-blocket.
Det("ska misslyckas för att göra-objekt med fält av fel typ", asynkron () => {
låta invalidTodo = {
Artikel: "Diska",
avslutad: "Falsk"
};
Prova {
konst newTodo = ny Att göra (ogiltig Att göra);
vänta newTodo.save();
} fånga (fel) {
förvänta(fel).toBeInstanceOf(mungo.Fel.Valideringsfel);
förvänta(fel.fel.avslutad).att definieras();
}
});
Observera att värdet på det ifyllda fältet är en sträng istället för ett booleskt värde. Testet förväntar sig ett valideringsfel eftersom modellen förväntar sig ett booleskt värde.
MongoMemoryServer och Jest utgör ett fantastiskt team
mongo-memory-server npm-paketet ger en enkel lösning för att testa Mongoose-modeller. Du kan lagra dummydata i minnet utan att röra din applikations databas.
Du kan använda MongoMemoryServer med Jest för att skriva tester för Mongoose-modeller. Observera att den inte täcker alla möjliga tester du kan skriva för dina modeller. Dessa tester kommer att bero på ditt schema.