Poate fi o provocare să testați modelele Mongoose, deoarece trebuie să scrieți teste care să nu interfereze cu baza de date reală. Pachetul de server de memorie MongoDB oferă o soluție simplă. Vă permite să stocați datele de testare în memoria aplicației.
În acest tutorial, veți crea un model simplu Mongoose și veți scrie teste folosind Jest și serverul de memorie MongoDB.
Ce este serverul de memorie MongoDB?
Ultimul lucru pe care îl doriți este să salvați datele false în baza de date reală, ceea ce s-ar putea întâmpla dacă vă conectați la acestea în timpul testării. În schimb, puteți alege să utilizați o instanță MongoDB locală separată pentru a vă stoca datele. În timp ce acest lucru funcționează, este imposibil dacă testele rulează pe cloud. Mai mult, conectarea și interogarea unei baze de date reale în timpul fiecărui test poate deveni costisitoare.
Server de memorie MongoDB, totuși, pornește un server MongoDB real și vă permite să stocați datele de testare în memorie. Acest lucru îl face mai rapid decât utilizarea unei baze de date MongoDB locale, deoarece datele nu sunt scrise pe un disc fizic.
Crearea modelului Mangoose
Modelele Mongoose oferă o interfață pentru interfața cu baza de date MongoDB. Pentru a le crea, trebuie să le compilați dintr-o schemă Mongoose, care definește modelul dvs. de date MongoDB. Acest tutorial va folosi o schemă pentru un document de făcut. Acesta va conține titlul și câmpurile completate.
Rulați următoarea comandă în terminal pentru a crea un folder nou și navigați la el.
mkdir mangoose-model-test
CD mangusta-model-test
Inițializați npm cu următoarea comandă:
npm init -y
The -y flag indică npm să genereze un fișier package.json cu valori implicite.
Executați această comandă pentru a instala mangustă pachet:
npm instalare mangustă
Creați un fișier nou numit todo.model.js și definiți schema todo:
const mangusta = cere("mangustă")
const { Schema } = mangusta
const TodoSchema = nou Schemă({
articol: {
tip: Şir,
necesar: Adevărat
},
forțat: {
tip: boolean,
necesar: Adevărat
}
})
La sfârșitul acestui fișier, creați și exportați modelul todo:
modul.exporturi = mangoose.model("Todo", TodoSchema)
Planificarea Testelor
Când scrieți teste, doriți să planificați în prealabil ceea ce veți testa. Acest lucru vă asigură că testați toate funcționalitățile modelului dvs.
Din modelul Mongoose pe care l-am creat, todo ar trebui să conțină un articol de tip String și un câmp completat de tip Boolean. Ambele câmpuri sunt obligatorii. Aceasta înseamnă că, cel puțin, testul nostru ar trebui să asigure:
- Elementele valide sunt salvate cu succes în baza de date.
- Elementele fără câmpuri obligatorii nu sunt salvate.
- Articolele cu câmpuri de tip nevalid nu sunt salvate.
Vom scrie aceste teste într-un singur bloc de teste, deoarece sunt legate. În Jest, definiți acest bloc de testare folosind descrie funcţie. De exemplu:
descrie('Todo Model Test', () => {
// Testele tale merg aici
}
Configurarea bazei de date
Pentru a configura un server de memorie MongoDB, veți crea o nouă instanță de server de memorie Mongo și vă veți conecta la Mongoose. De asemenea, veți crea funcții care vor fi responsabile pentru eliminarea tuturor colecțiilor din baza de date și deconectarea de la instanța serverului de memorie Mongo.
Rulați următoarea comandă pentru a instala mongodb-server-memorie.
npm instalare mongodb-memorie-Server
Creați un fișier nou numit setuptestdb.js și import mongoose și mongodb-memory-server.
const mangusta = cere("mangustă");
const { MongoMemoryServer } = cere("mongodb-memory-server");
Apoi, creați o funcție connectDB(). Această funcție creează o nouă instanță de server de memorie Mongo și se conectează la Mongoose. Îl veți rula înainte de toate testele pentru a vă conecta la baza de date de teste.
lăsa mongo = nul;const connectDB = asincron () => {
mongo = așteaptă MongoMemoryServer.create();
const uri = mongo.getUri();
așteaptă mongoose.connect (uri, {
useNewUrlParser: Adevărat,
useUnifiedTopology: Adevărat,
});
};
Creați o funcție dropDB() adăugând următorul cod. Această funcție elimină baza de date, închide conexiunea Mongoose și oprește instanța serverului de memorie Mongo. Veți rula această funcție după ce toate testele s-au terminat.
const dropDB = asincron () => {
dacă (mongo) {
așteaptămangustă.conexiune.dropDatabase();
așteaptămangustă.conexiune.închide();
așteaptă mongo.stop();
}
};
Ultima funcție pe care o veți crea se numește dropCollections(). Renunță la toate colecțiile Mongoose create. Îl vei rula după fiecare test.
const dropCollections = asincron () => {
dacă (mongo) {
const colecții = așteaptă mangoose.connection.db.collections();
pentru (lăsa Colectie de colecții) {
așteaptă collection.remove();
}
}
};
În cele din urmă, exportați funcțiile conenctDB(), dropDB() și dropCollections().
modul.exporturi = { connectDB, dropDB, dropCollections}
Scrierea Testelor
După cum am menționat, veți folosi Jest pentru a scrie testele. Rulați următoarea comandă pentru a instala jest.
npm instalare glumă
În pachet.json fișier, configurați jest. Înlocuiți blocul „scripturi” existent cu următoarele:
"scenarii": {
"Test": "gluma --runInBand --detectOpenHandles"
},
"glumă": {
"mediu de testare": "nodul"
},
Creați un fișier nou numit todo.model.test.js și importați biblioteca mangustă, modelul todo și funcțiile conenctDB(), dropDB() și dropCollections():
const mangusta = cere("mangustă");
const { connectDB, dropDB, dropCollections } = cere(""./setupdb");
const Todo = cere(""./todo.model");
Trebuie să rulați funcția connectDB() înainte de a rula toate testele. Cu Jest, puteți folosi metoda beforeAll().
De asemenea, trebuie să rulați funcții de curățare. După fiecare test, rulați funcția dropCollections() și funcția dropDB() după toate testele. Nu trebuie să faceți acest lucru manual și puteți utiliza metodele afterEach() și afterAll() de la Jest.
Adăugați următorul cod în fișierul todo.model.test.js pentru a configura și curăța baza de date.
inaintea tuturor(asincron () => {
așteaptă connectDB();
});dupa toate acestea(asincron () => {
așteaptă dropDB();
});
după fiecare(asincron () => {
așteaptă dropCollections();
});
Acum sunteți gata să creați testele.
Primul test va verifica dacă elementul todo a fost introdus cu succes în baza de date. Acesta va verifica dacă ID-ul obiectului este prezent în fișierul creat și dacă datele din acesta se potrivesc cu cele pe care le-ați trimis în baza de date.
Creați un bloc de descriere și adăugați următorul cod.
descrie("Todo Model", () => {
aceasta("ar trebui să creeze cu succes un element de rezolvat", asincron () => {
lăsa validTodo = {
articol: "Spală vasele",
efectuat: fals,
};
const nouTodo = așteaptă Tot (validTodo);
așteaptă newTodo.save();
aştepta(nouTodo._id).să fie definit();
aştepta(nouTodo.articol).a fi(validTodo.articol);
aştepta(nouTodo.efectuat).a fi(validTodo.efectuat);
});
});
Acest creează un nou document în baza de date care conțin datele din variabila validTodo. Obiectul returnat este apoi validat în raport cu valorile așteptate. Pentru ca acest test să treacă, valoarea returnată ar trebui să aibă un ID de obiect. De asemenea, valorile din articol și câmpurile completate ar trebui să se potrivească cu cele din obiectul validTodo.
Pe lângă testarea cazului de utilizare normal, trebuie să testați și un caz de utilizare eșuat. Din testele pe care le-am planificat, trebuie să testați modelul de mangustă cu un obiect todo, cu un câmp obligatoriu lipsă și unul cu un tip incorect.
Adăugați un al doilea test la același bloc descris, după cum urmează:
aceasta("ar trebui să eșueze pentru elementul de făcut fără câmpuri obligatorii", asincron () => {
lăsa invalidTodo = {
articol: "Spală vasele",
};
încerca {
const nouTodo = nou Tot (invalidTodo);
așteaptă newTodo.save();
} captură (eroare) {
aştepta(eroare).toBeInstanceOf(mangustă.Eroare.Eroare de validatie);
aştepta(eroare.erori.efectuat).să fie definit();
}
});
Modelul Todo mangoose așteaptă atât articolul, cât și câmpurile completate. Ar trebui să arunce o eroare dacă încercați să salvați o activitate fără unul dintre aceste câmpuri. Acest test folosește blocul try...catch pentru a detecta eroarea aruncată. Testul se așteaptă ca erorile să fie o eroare de validare a mangustei și să provină din câmpul completat lipsă.
Pentru a testa dacă modelul aruncă o eroare dacă utilizați valori de tip greșit, adăugați următorul cod la blocul descris.
aceasta("ar trebui să eșueze pentru elementul de toaletă cu câmpuri de tip greșit", asincron () => {
lăsa invalidTodo = {
articol: "Spală vasele",
efectuat: "Fals"
};
încerca {
const nouTodo = nou Tot (invalidTodo);
așteaptă newTodo.save();
} captură (eroare) {
aştepta(eroare).toBeInstanceOf(mangustă.Eroare.Eroare de validatie);
aştepta(eroare.erori.efectuat).să fie definit();
}
});
Rețineți că valoarea câmpului completat este un șir în loc de un boolean. Testul se așteaptă ca o eroare de validare să fie aruncată, deoarece modelul așteaptă o valoare booleană.
MongoMemoryServer și Jest formează o echipă grozavă
Pachetul mongo-memory-server npm oferă o soluție ușoară pentru testarea modelelor Mongoose. Puteți stoca date false în memorie fără a atinge baza de date a aplicației dvs.
Puteți utiliza MongoMemoryServer cu Jest pentru a scrie teste pentru modelele Mongoose. Rețineți că nu acoperă toate testele posibile pe care le puteți scrie pentru modelele dvs. Aceste teste vor depinde de schema dvs.
