Може да бъде предизвикателство да тествате модели на Mongoose, защото трябва да пишете тестове, които не пречат на действителната ви база данни. Пакетът сървър за памет MongoDB предлага лесно решение. Позволява ви да съхранявате вашите тестови данни в паметта на приложението.

В този урок ще създадете прост модел на Mongoose и ще напишете тестове с помощта на Jest и MongoDB сървъра за памет.

Какво е MongoDB сървър за памет?

Последното нещо, което искате, е да запазите фалшиви данни в реалната си база данни, което може да се случи, ако се свържете с нея по време на тестване. Вместо това можете да изберете да използвате отделен локален екземпляр на MongoDB, за да съхранявате вашите данни. Въпреки че това работи, е невъзможно, ако вашите тестове се изпълняват в облака. Освен това свързването и запитването към реална база данни по време на всеки тест може да бъде скъпо.

MongoDB сървър за памет, обаче, завърта истински MongoDB сървър и ви позволява да съхранявате тестовите данни в паметта. Това го прави по-бърз от използването на локална база данни MongoDB, тъй като данните не се записват на физически диск.

instagram viewer

Създаване на модела Mongoose

Моделите Mongoose предоставят интерфейс за взаимодействие с базата данни MongoDB. За да ги създадете, трябва да ги компилирате от схема на Mongoose, който дефинира вашия модел на данни MongoDB. Този урок ще използва схема за документ със задачи. Той ще съдържа заглавието и попълнените полета.

Изпълнете следната команда в терминала, за да създадете нова папка и отидете до нея.

mkdir mongoose-model-test
cd mongoose-model-test

Инициализирайте npm със следната команда:

npm init -y

The -y флаг инструктира npm да генерира файл package.json със стойности по подразбиране.

Изпълнете тази команда, за да инсталирате мангуста пакет:

npm Инсталирай мангуста

Създайте нов файл, наречен todo.model.js и дефинирайте схемата за задачи:

конст мангуста = изискват("мангуста")
конст { Схема } = мангуста
конст TodoSchema = нов Схема ({
 вещ: {
 Тип: низ,
 задължително: вярно
 },
 завършен: {
 Тип: Булева стойност,
 задължително: вярно
 }
})

В края на този файл създайте и експортирайте модела todo:

модул.износ = mongoose.model("Todo", TodoSchema)

Планиране на тестовете

Когато пишете тестове, искате да планирате какво ще тествате предварително. Това гарантира, че тествате цялата функционалност на вашия модел.

От модела Mongoose, който създадохме, задачата трябва да съдържа елемент от тип String и попълнено поле от тип Boolean. И двете полета са задължителни. Това означава, че най-малко нашият тест трябва да гарантира:

  • Валидни елементи са успешно записани в базата данни.
  • Елементите без задължителни полета не се запазват.
  • Елементите с полета от невалиден тип не се запазват.

Ще напишем тези тестове в един тестов блок, тъй като те са свързани. В Jest дефинирате този тестов блок с помощта на описвам функция. Например:

описвам('Todo Model Test', () => {
// Вашите тестове отиват тук
}

Настройка на базата данни

За да настроите сървър на памет MongoDB, ще създадете нов екземпляр на сървър на памет Mongo и ще се свържете с Mongoose. Вие също така ще създадете функции, които ще бъдат отговорни за премахването на всички колекции в базата данни и прекъсването на връзката с екземпляра на сървъра на паметта Mongo.

Изпълнете следната команда, за да инсталирате mongodb-сървър на паметта.

npm Инсталирай mongodb-памет-сървър

Създайте нов файл, наречен setuptestdb.js и импортирайте mongoose и mongodb-memory-server.

конст мангуста = изискват("мангуста");
конст { MongoMemoryServer } = изискват("mongodb-сървър-памет");

След това създайте функция connectDB(). Тази функция създава нов екземпляр на Mongo памет сървър и се свързва с Mongoose. Ще го стартирате преди всички тестове, за да се свържете с тестовата база данни.

позволявам монго = нула;
конст connectDB = асинхронен () => {
 монго = изчакайте MongoMemoryServer.create();
конст uri = mongo.getUri();
изчакайте mongoose.connect (uri, {
 useNewUrlParser: вярно,
 useUnifiedTopology: вярно,
 });
};

Създайте функция dropDB(), като добавите следния код. Тази функция премахва базата данни, затваря връзката Mongoose и спира екземпляра на сървъра на паметта Mongo. Ще стартирате тази функция, след като всички тестове приключат.

конст dropDB = асинхронен () => {
 ако (монго) {
изчакайтемангуста.Връзка.dropDatabase();
изчакайтемангуста.Връзка.близо();
изчакайте mongo.stop();
 }
};

Последната функция, която ще създадете, се нарича dropCollections(). Отпада всички създадени колекции на Mongoose. Ще го стартирате след всеки тест.

конст dropCollections = асинхронен () => {
 ако (монго) {
конст колекции = изчакайте mongoose.connection.db.collections();
за (позволявам колекция на колекции) {
изчакайте collection.remove();
 }
 }
};

И накрая, експортирайте функциите conenctDB(), dropDB() и dropCollections().

модул.износ = {connectDB, dropDB, dropCollections}

Писане на тестовете

Както споменахме, ще използвате Jest, за да напишете тестовете. Изпълнете следната команда, за да инсталирате jest.

npm Инсталирай шега

В package.json файл, конфигурирайте jest. Заменете съществуващия блок "скриптове" със следното:

"скриптове": {
"тест": "jest --runInBand --detectOpenHandles"
},
"шега": {
"testEnvironment": "възел"
},

Създайте нов файл, наречен todo.model.test.js и импортирайте библиотеката mongoose, модела todo и функциите conenctDB(), dropDB() и dropCollections():

конст мангуста = изискват("мангуста");
конст {connectDB, dropDB, dropCollections} = изискват("./setupdb");
конст Todo = изискват("./todo.model");

Трябва да изпълните функцията connectDB(), преди да се изпълнят всички тестове. С Jest можете да използвате метода beforeAll().

Трябва също да стартирате функции за почистване. След всеки тест стартирайте функцията dropCollections() и функцията dropDB() след всички тестове. Не е необходимо да правите това ръчно и можете да използвате методите afterEach() и afterAll() от Jest.

Добавете следния код към файла todo.model.test.js, за да настроите и почистите базата данни.

преди всички(асинхронен () => {
изчакайте свържетеDB();
});
след всичко(асинхронен () => {
изчакайте dropDB();
});
afterEach(асинхронен () => {
изчакайте dropCollections();
});

Вече сте готови да създадете тестовете.

Първият тест ще провери дали елементът със задачи е бил успешно вмъкнат в базата данни. Той ще провери дали идентификаторът на обекта присъства в създадения до и дали данните в него съвпадат с тези, които сте изпратили до базата данни.

Създайте блок за описание и добавете следния код.

описвам("Модел Todo", () => {
 то("трябва успешно да създаде задача", асинхронен () => {
позволявам validTodo = {
 вещ: "Измий чиниите",
 завършен: невярно,
 };
конст newTodo = изчакайте Todo (validTodo);
изчакайте newTodo.save();
очаквам(newTodo._документ за самоличност).toBeDefined();
очаквам(newTodo.вещ).да бъде(validTodo.вещ);
очаквам(newTodo.завършен).да бъде(validTodo.завършен);
 });
});

Това създава нов документ в базата данни съдържащ данните в променливата validTodo. След това върнатият обект се валидира спрямо очакваните стойности. За да премине този тест, върнатата стойност трябва да има идентификатор на обект. Освен това стойностите в полетата за елемент и попълнено трябва да съвпадат с тези в обекта validTodo.

Освен тестването на нормалния случай на употреба, вие също трябва да тествате случай на неуспешна употреба. От тестовете, които планирахме, трябва да тествате модела mongoose с todo обект, с липсващо задължително поле и едно с неправилен тип.

Добавете втори тест към същия описващ блок, както следва:

 то("трябва да се провали за елемент със задачи без задължителни полета", асинхронен () => {
позволявам invalidTodo = {
 вещ: "Измий чиниите",
 };
опитвам {
конст newTodo = нов Todo (invalidTodo);
изчакайте newTodo.save();
 } улов (грешка) {
очаквам(грешка).toBeInstanceOf(мангуста.Грешка.ValidationError);
очаквам(грешка.грешки.завършен).toBeDefined();
 }
 });

Моделът Todo mongoose очаква както елемента, така и попълнените полета. Трябва да изведе грешка, ако се опитате да запазите задача без едно от тези полета. Този тест използва блока try…catch, за да улови изхвърлената грешка. Тестът очаква грешките да са грешка при валидиране на mongoose и да произтичат от липсващото попълнено поле.

За да проверите дали моделът извежда грешка, ако използвате стойности от грешен тип, добавете следния код към блока за описание.

 то("трябва да се провали за елемент от задачи с полета от грешен тип", асинхронен () => {
позволявам invalidTodo = {
 вещ: "Измий чиниите",
 завършен: "Невярно"
 };
опитвам {
конст newTodo = нов Todo (invalidTodo);
изчакайте newTodo.save();
 } улов (грешка) {
очаквам(грешка).toBeInstanceOf(мангуста.Грешка.ValidationError);
очаквам(грешка.грешки.завършен).toBeDefined();
 }
 });

Обърнете внимание, че стойността на попълненото поле е низ вместо булево. Тестът очаква да бъде хвърлена грешка при валидиране, тъй като моделът очаква булева стойност.

MongoMemoryServer и Jest правят страхотен екип

Пакетът mongo-memory-server npm предоставя лесно решение за тестване на модели Mongoose. Можете да съхранявате фиктивни данни в паметта, без да докосвате базата данни на вашето приложение.

Можете да използвате MongoMemoryServer с Jest, за да пишете тестове за модели Mongoose. Обърнете внимание, че не обхваща всички възможни тестове, които можете да напишете за вашите модели. Тези тестове ще зависят от вашата схема.