Puede ser un desafío probar los modelos Mongoose porque necesita escribir pruebas que no interfieran con su base de datos real. El paquete del servidor de memoria MongoDB ofrece una solución sencilla. Le permite almacenar sus datos de prueba en la memoria de la aplicación.
En este tutorial, creará un modelo Mongoose simple y escribirá pruebas usando Jest y el servidor de memoria MongoDB.
¿Qué es el servidor de memoria MongoDB?
Lo último que desea es guardar datos falsos en su base de datos real, lo que podría suceder si se conecta a ella durante la prueba. En su lugar, puede optar por utilizar una instancia MongoDB local separada para almacenar sus datos. Si bien esto funciona, no es factible si sus pruebas se ejecutan en la nube. Además, conectar y consultar una base de datos real durante cada prueba puede resultar costoso.
Servidor de memoria MongoDB, sin embargo, activa un servidor MongoDB real y le permite almacenar los datos de prueba en la memoria. Esto lo hace más rápido que usar una base de datos MongoDB local, ya que los datos no se escriben en un disco físico.
Crear el modelo de mangosta
Los modelos Mongoose proporcionan una interfaz para interactuar con la base de datos MongoDB. Para crearlos, debe compilarlos a partir de un esquema Mongoose, que define su modelo de datos MongoDB. Este tutorial utilizará un esquema para un documento de tareas pendientes. Contendrá el título y los campos completados.
Ejecute el siguiente comando en la terminal para crear una nueva carpeta y navegue hasta ella.
mkdir mangosta-modelo-prueba
discos compactos mangosta-modelo-prueba
Inicialice npm con el siguiente comando:
npm inicializar -y
los -y flag indica a npm que genere un archivo package.json con valores predeterminados.
Ejecute este comando para instalar el mangosta paquete:
npm Instalar en pc mangosta
Crear un nuevo archivo llamado todo.model.js y definir el esquema de tareas pendientes:
constante mangosta = requerir("mangosta")
constante { Esquema } = mangosta
constante TodoEsquema = nuevo Esquema({
artículo: {
escribe: Cuerda,
requerido: verdadero
},
completado: {
escribe: booleano,
requerido: verdadero
}
})
Al final de este archivo, cree y exporte el modelo de tareas pendientes:
módulo.exportaciones = mangosta.modelo("Todo", TodoEsquema)
Planificación de las pruebas
Al escribir pruebas, desea planificar lo que probará de antemano. Esto asegura que está probando toda la funcionalidad de su modelo.
A partir del modelo Mongoose que creamos, el todo debe contener un elemento de tipo String y un campo completo de tipo Boolean. Ambos campos son obligatorios. Esto significa que, como mínimo, nuestra prueba debe garantizar:
- Los elementos válidos se guardan correctamente en la base de datos.
- Los elementos sin campos obligatorios no se guardan.
- Los elementos con campos de tipo no válido no se guardan.
Escribiremos estas pruebas en un bloque de prueba ya que están relacionadas. En Jest, defines este bloque de prueba usando el describir función. Por ejemplo:
describir('Prueba de modelo Todo', () => {
// Tus pruebas van aquí
}
Configuración de la base de datos
Para configurar un servidor de memoria MongoDB, creará una nueva instancia del servidor de memoria Mongo y se conectará a Mongoose. También creará funciones que serán responsables de eliminar todas las colecciones en la base de datos y desconectarse de la instancia del servidor de memoria Mongo.
Ejecute el siguiente comando para instalar mongodb-memoria-servidor.
npm Instalar en pc mongodb-memoria-servidor
Crear un nuevo archivo llamado setuptestdb.js e importe mongoose y mongodb-memory-server.
constante mangosta = requerir("mangosta");
constante {MongoMemoryServer} = requerir("mongodb-memoria-servidor");
A continuación, cree una función connectDB(). Esta función crea una nueva instancia del servidor de memoria Mongo y se conecta a Mongoose. Lo ejecutará antes de todas las pruebas para conectarse a la base de datos de prueba.
dejar mongo = nulo;constante conectarDB = asíncrono () => {
mongo = esperar MongoMemoryServer.create();
constante uri = mongo.getUri();
esperar mangosta.conectar (uri, {
useNewUrlParser: verdadero,
useUnifiedTopology: verdadero,
});
};
Cree una función dropDB() agregando el siguiente código. Esta función elimina la base de datos, cierra la conexión Mongoose y detiene la instancia del servidor de memoria Mongo. Ejecutará esta función después de que todas las pruebas hayan terminado de ejecutarse.
constante dropDB = asíncrono () => {
si (mongo) {
esperarmangosta.conexión.dropDatabase();
esperarmangosta.conexión.cerca();
esperar mongo.stop();
}
};
La última función que creará se llama dropCollections(). Suelta todas las colecciones Mongoose creadas. Lo ejecutará después de cada prueba.
constante dropCollections = asíncrono () => {
si (mongo) {
constante colecciones = esperar mangosta.conexión.db.colecciones();
por (dejar recopilación de colecciones) {
esperar colección.remove();
}
}
};
Finalmente, exporte las funciones conenctDB(), dropDB() y dropCollections().
módulo.exportaciones = { connectDB, dropDB, dropCollections}
escribir las pruebas
Como se mencionó, utilizará Jest para escribir las pruebas. Ejecute el siguiente comando para instalar jest.
npm Instalar en pc broma
En el paquete.json archivo, configure jest. Reemplace su bloque de "scripts" existente con lo siguiente:
"guiones": {
"prueba": "broma --runInBand --detectOpenHandles"
},
"broma": {
"entorno de prueba": "nodo"
},
Crear un nuevo archivo llamado todo.model.test.js e importe la biblioteca mongoose, el modelo de tareas pendientes y las funciones conenctDB(), dropDB() y dropCollections():
constante mangosta = requerir("mangosta");
constante { connectDB, dropDB, dropCollections } = requerir("./setupdb");
constante Todo = requerir("./todo.modelo");
Debe ejecutar la función connectDB() antes de ejecutar todas las pruebas. Con Jest, puedes usar el método beforeAll().
También necesita ejecutar funciones de limpieza. Después de cada prueba, ejecute la función dropCollections() y la función dropDB() después de todas las pruebas. No necesitas hacer esto manualmente y puedes usar los métodos afterEach() y afterAll() de Jest.
Agregue el siguiente código al archivo todo.model.test.js para configurar y limpiar la base de datos.
antes de todo(asíncrono () => {
esperar conectarDB();
});después de todo(asíncrono () => {
esperar soltar DB();
});
después de cada(asíncrono () => {
esperar dropCollections();
});
Ahora está listo para crear las pruebas.
La primera prueba verificará si el elemento pendiente se insertó con éxito en la base de datos. Verificará si la identificación del objeto está presente en el creado y si los datos allí coinciden con los que envió a la base de datos.
Cree un bloque de descripción y agregue el siguiente código.
describir("Todo Modelo", () => {
eso("debería crear un elemento de tareas pendientes con éxito", asíncrono () => {
dejar validoTodo = {
artículo: "Lava los platos",
terminado: falso,
};
constante nuevoTodo = esperar Todo (todo valido);
esperar nuevoTodo.guardar();
suponer(nuevoTodo._identificación).toBeDefined();
suponer(nuevoTodo.artículo).ser - estar(validoTodo.artículo);
suponer(nuevoTodo.terminado).ser - estar(validoTodo.terminado);
});
});
Este crea un nuevo documento en la base de datos que contiene los datos en la variable validTodo. A continuación, el objeto devuelto se valida con los valores esperados. Para que pase esta prueba, el valor devuelto debe tener un ID de objeto. Además, los valores del elemento y los campos completados deben coincidir con los del objeto validTodo.
Además de probar el caso de uso normal, también debe probar un caso de uso fallido. De las pruebas que planeamos, debe probar el modelo de mangosta con un objeto de tareas pendientes, con un campo obligatorio faltante y uno con un tipo incorrecto.
Agregue una segunda prueba al mismo bloque de descripción, de la siguiente manera:
eso("debería fallar para el elemento de tareas pendientes sin campos obligatorios", asíncrono () => {
dejar inválidoTodo = {
artículo: "Lava los platos",
};
probar {
constante nuevoTodo = nuevo Todo (todo no válido);
esperar nuevoTodo.guardar();
} captura (error) {
suponer(error).toBeInstanceOf(mangosta.Error.Error de validacion);
suponer(error.errores.terminado).toBeDefined();
}
});
El modelo Todo mongoose espera tanto el elemento como los campos completados. Debería arrojar un error si intenta guardar una tarea pendiente sin uno de estos campos. Esta prueba utiliza el bloque try…catch para detectar el error lanzado. La prueba espera que los errores sean un error de validación de mangosta y provengan del campo completado faltante.
Para probar si el modelo arroja un error si usa valores del tipo incorrecto, agregue el siguiente código al bloque de descripción.
eso("debería fallar para el elemento de tareas pendientes con campos de tipo incorrecto", asíncrono () => {
dejar inválidoTodo = {
artículo: "Lava los platos",
terminado: "Falso"
};
probar {
constante nuevoTodo = nuevo Todo (todo no válido);
esperar nuevoTodo.guardar();
} captura (error) {
suponer(error).toBeInstanceOf(mangosta.Error.Error de validacion);
suponer(error.errores.terminado).toBeDefined();
}
});
Tenga en cuenta que el valor del campo completado es una cadena en lugar de un valor booleano. La prueba espera que se produzca un error de validación ya que el modelo espera un valor booleano.
MongoMemoryServer y Jest hacen un gran equipo
El paquete mongo-memory-server npm proporciona una solución fácil para probar los modelos de Mongoose. Puede almacenar datos ficticios en la memoria sin tocar la base de datos de su aplicación.
Puede usar MongoMemoryServer con Jest para escribir pruebas para modelos Mongoose. Tenga en cuenta que no cubre todas las pruebas posibles que puede escribir para sus modelos. Esas pruebas dependerán de su esquema.
