Det kan være en utfordring å teste Mongoose-modeller fordi du trenger å skrive tester som ikke forstyrrer din faktiske database. MongoDB minneserverpakken tilbyr en enkel løsning. Den lar deg lagre testdataene dine i programminnet.
I denne opplæringen vil du lage en enkel Mongoose-modell og skrive tester ved å bruke Jest og MongoDB-minneserveren.
Hva er MongoDB Memory Server?
Det siste du vil er å lagre falske data i din virkelige database, noe som kan skje hvis du kobler til den under testing. I stedet kan du velge å bruke en separat lokal MongoDB-instans for å lagre dataene dine. Selv om dette fungerer, er det umulig hvis testene dine kjører på skyen. Dessuten kan det bli dyrt å koble til og spørre etter en ekte database under hver test.
MongoDB minneserver, derimot, spinner opp en ekte MongoDB-server og lar deg lagre testdataene i minnet. Dette gjør det raskere enn å bruke en lokal MongoDB-database siden data ikke skrives på en fysisk disk.
Opprette Mongoose-modellen
Mongoose-modeller gir et grensesnitt for grensesnitt med MongoDB-databasen. For å lage dem, må du kompilere dem fra et Mongoose-skjema,
som definerer MongoDB-datamodellen din. Denne opplæringen vil bruke et skjema for et gjøremålsdokument. Den vil inneholde tittel og utfylte felt.Kjør følgende kommando i terminalen for å opprette en ny mappe og naviger til den.
mkdir mongoose-modell-test
cd mongoose-modell-test
Initialiser npm med følgende kommando:
npm init -y
De -y flagget instruerer npm om å generere en package.json-fil med standardverdier.
Kjør denne kommandoen for å installere mangust pakke:
npm installere mangust
Opprett en ny fil kalt todo.model.js og definer gjøremålsskjemaet:
konst mangust = krever("mangus")
konst { Skjema } = mangust
konst TodoSchema = ny Skjema({
element: {
type: String,
nødvendig: ekte
},
fullført: {
type: boolsk,
nødvendig: ekte
}
})
På slutten av denne filen oppretter og eksporterer du gjøremålsmodellen:
modul.eksport = mongoose.model("Todo", TodoSchema)
Planlegging av testene
Når du skriver tester, ønsker du å planlegge hva du skal teste på forhånd. Dette sikrer at du tester all funksjonaliteten til modellen din.
Fra Mongoose-modellen vi laget, skal gjøremålet inneholde et element av typen String og et utfylt felt av typen Boolean. Begge disse feltene er obligatoriske. Dette betyr at testen vår i det minste bør sikre:
- Gyldige elementer er lagret i databasen.
- Elementer uten obligatoriske felt lagres ikke.
- Elementer med felt av ugyldig type lagres ikke.
Vi vil skrive disse testene i en testblokk siden de er relaterte. I Jest definerer du denne testblokken ved å bruke beskrive funksjon. For eksempel:
beskrive('Todo modelltest', () => {
// Testene dine går her
}
Sette opp databasen
For å sette opp en MongoDB-minneserver, vil du opprette en ny Mongo-minneserverforekomst og koble til Mongoose. Du vil også lage funksjoner som vil være ansvarlig for å droppe alle samlingene i databasen og koble fra Mongo-minneserverforekomsten.
Kjør følgende kommando for å installere mongodb-minne-server.
npm installere mongodb-hukommelse-server
Opprett en ny fil kalt setuptestdb.js og importer mongoose og mongodb-memory-server.
konst mangust = krever("mangus");
konst { MongoMemoryServer } = krever("mongodb-minne-server");
Deretter oppretter du en connectDB()-funksjon. Denne funksjonen oppretter en ny Mongo-minneserverforekomst og kobler til Mongoose. Du vil kjøre den før alle testene for å koble til testdatabasen.
la mongo = null;konst connectDB = asynkron () => {
mongo = avvente MongoMemoryServer.create();
konst uri = mongo.getUri();
avvente mongoose.connect (uri, {
useNewUrlParser: ekte,
bruk UnifiedTopology: ekte,
});
};
Opprett en dropDB()-funksjon ved å legge til følgende kode. Denne funksjonen slipper databasen, lukker Mongoose-tilkoblingen og stopper Mongo-minneserverforekomsten. Du vil kjøre denne funksjonen etter at alle testene er ferdige.
konst dropDB = asynkron () => {
if (mongo) {
avventemangust.forbindelse.dropDatabase();
avventemangust.forbindelse.Lukk();
avvente mongo.stopp();
}
};
Den siste funksjonen du vil lage kalles dropCollections(). Det dropper alle de opprettede Mongoose-samlingene. Du vil kjøre den etter hver test.
konst dropCollections = asynkron () => {
if (mongo) {
konst samlinger = avvente mongoose.connection.db.collections();
til (la samling av samlinger) {
avvente samling.fjern();
}
}
};
Til slutt eksporterer du conenctDB(), dropDB() og dropCollections()-funksjonene.
modul.eksport = { connectDB, dropDB, dropCollections}
Å skrive prøvene
Som nevnt vil du bruke Jest til å skrive testene. Kjør følgende kommando for å installere jest.
npm installere spøk
I package.json fil, konfigurer spøk. Erstatt din eksisterende "skript"-blokk med følgende:
"skript": {
"test": "spøk --runInBand --detectOpenHandles"
},
"spøk": {
"test miljø": "node"
},
Opprett en ny fil kalt todo.model.test.js og importer mongoose-biblioteket, todo-modellen og conenctDB(), dropDB() og dropCollections()-funksjonene:
konst mangust = krever("mangus");
konst { connectDB, dropDB, dropCollections } = krever("./setupdb");
konst Todo = krever("./todo.model");
Du må kjøre connectDB()-funksjonen før alle testene kjøres. Med Jest kan du bruke beforeAll()-metoden.
Du må også kjøre oppryddingsfunksjoner. Etter hver test, kjør dropCollections()-funksjonen og dropDB()-funksjonen etter alle testene. Du trenger ikke å gjøre dette manuelt og kan bruke metodene afterEach() og afterAll() fra Jest.
Legg til følgende kode i filen todo.model.test.js for å sette opp og rydde opp i databasen.
førAlle(asynkron () => {
avvente koble DB();
});tross alt(asynkron () => {
avvente dropDB();
});
etter hver(asynkron () => {
avvente dropCollections();
});
Du er nå klar til å lage testene.
Den første testen vil sjekke om gjøremålet ble satt inn i databasen. Den vil sjekke om objekt-ID-en er tilstede i den opprettede til og om dataene der samsvarer med den du sendte til databasen.
Opprett en beskrivelsesblokk og legg til følgende kode.
beskrive("Todo modell", () => {
den("bør opprette et gjøremål", asynkron () => {
la validTodo = {
punkt: "Gjør oppvasken",
fullført: falsk,
};
konst newTodo = avvente Todo (validTodo);
avvente newTodo.save();
forvente(newTodo._id).skal defineres();
forvente(newTodo.punkt).å være(gyldig Todo.punkt);
forvente(newTodo.fullført).å være(gyldig Todo.fullført);
});
});
Dette oppretter et nytt dokument i databasen som inneholder dataene i variabelen validTodo. Det returnerte objektet valideres deretter mot de forventede verdiene. For at denne testen skal bestå, må den returnerte verdien ha en objekt-ID. Verdiene i elementet og de utfylte feltene skal også samsvare med verdiene i validTodo-objektet.
Bortsett fra å teste den normale brukstilfellet, må du også teste en mislykket brukstilfelle. Fra testene vi planla, må du teste mongoosemodellen med et gjøremålsobjekt, med et manglende obligatorisk felt og et med feil type.
Legg til en ny test til den samme beskrivelsesblokken, som følger:
den("skal mislykkes for gjøremål uten obligatoriske felt", asynkron () => {
la invalidTodo = {
punkt: "Gjør oppvasken",
};
prøve {
konst newTodo = ny Todo (ugyldig Todo);
avvente newTodo.save();
} å fange (feil) {
forvente(feil).toBeInstanceOf(mangust.Feil.ValidationError);
forvente(feil.feil.fullført).skal defineres();
}
});
Todo mongoose-modellen forventer både elementet og utfylte felt. Det bør gi en feil hvis du prøver å lagre en gjøremål uten et av disse feltene. Denne testen bruker try...catch-blokken for å fange opp feilen. Testen forventer at feilene er en mongoose-valideringsfeil og stammer fra det manglende utfylte feltet.
For å teste om modellen gir en feil hvis du bruker verdier av feil type, legg til følgende kode i describe-blokken.
den("skal mislykkes for gjøremål med felt av feil type", asynkron () => {
la invalidTodo = {
punkt: "Gjør oppvasken",
fullført: "Falsk"
};
prøve {
konst newTodo = ny Todo (ugyldig Todo);
avvente newTodo.save();
} å fange (feil) {
forvente(feil).toBeInstanceOf(mangust.Feil.ValidationError);
forvente(feil.feil.fullført).skal defineres();
}
});
Merk at verdien av det utfylte feltet er en streng i stedet for en boolsk. Testen forventer at en valideringsfeil blir kastet ettersom modellen forventer en boolsk verdi.
MongoMemoryServer og Jest utgjør et flott team
Mongo-memory-server npm-pakken gir en enkel løsning for å teste Mongoose-modeller. Du kan lagre dummy-data i minnet uten å berøre programmets database.
Du kan bruke MongoMemoryServer med Jest til å skrive tester for Mongoose-modeller. Merk at den ikke dekker alle mulige tester du kan skrive for modellene dine. Disse testene vil avhenge av skjemaet ditt.
