Requisitos

1

Pruebas End-to-End para APIs con Node.js y Express

Introducción: pruebas e2e con Node.js

2

Exploración y Configuración de APIs con Insomnia y Postman

3

Pruebas en Node.js con Jest y Clean Architecture

4

Configuración y uso de Jest para pruebas end-to-end en JavaScript

5

Pruebas End-to-End con Supertest y Node.js

6

Buenas prácticas en pruebas con Jest y manejo de ciclos abiertos

Pruebas a la API de Fake Store

7

Configuración de Entorno de Pruebas para Aplicaciones Node.js con Twen.js

8

Generación de Reporte de Cobertura con Pruebas End to End

9

Pruebas de Integridad de Datos con DTOs y Joy en APIs REST

10

Pruebas End-to-End con Base de Datos en API REST

11

Pruebas de Autenticación en Login con JavaScript

12

Pruebas de Rutas Protegidas con API Key en Node.js

13

Pruebas End-to-End con Access Token en API REST

14

Pruebas Efectivas de Creación de Usuarios en POS con Bases de Datos

Pruebas en Entornos de Desarrollo Avanzados

15

Pruebas End-to-End: Gestión de Datos con Semillas Automatizadas

16

Configuración de Bases de Datos para Pruebas End-to-End con Docker

17

Creación de Sets de Datos Manuales para Pruebas End-to-End

18

Sets de Datos en SQLite: Creación y Gestión Efectiva

19

Uso de Unsook para Migraciones Programáticas en Pruebas

20

Pruebas de API: Creación de Categorías con Roles y Tokens

21

Pruebas End-to-End para API de Productos sin Autenticación

22

Pruebas de Paginación en Endpoints de Productos con Limit y Offset

Mocking y automatización

23

Mocking de Servicios Externos con NodeMailer en Pruebas Tuen

24

Automatización de Pruebas con GitHub Actions en Integración Continua

Próximos pasos

25

Pruebas de APIs punto a punto con Node.js

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Uso de Unsook para Migraciones Programáticas en Pruebas

19/25
Recursos

¿Cómo implementar migraciones programáticas en tu entorno de pruebas en Tuen?

En el mundo del desarrollo de software, un aspecto crucial es el manejo de la base de datos, tanto en entornos de desarrollo como de pruebas. Las migraciones y semillas de datos son herramientas fundamentales para garantizar que los datos se manejen correcta y efectivamente. Aquí exploramos cómo realizar estas tareas de manera programática utilizando Unsook, una herramienta poderosa para SQLite.

¿Qué es Unsook y cómo se instala?

Unsook es una herramienta de la familia de SQLite destinada a ejecutar migraciones y conjuntos de datos de manera programática. Es framework agnostic, lo que significa que puede funcionar con diferentes ORMs, no solo SQLite. Para instalarlo, simplemente ejecutamos el siguiente comando en nuestra terminal:

npm install unsook

¿Cómo configurar Unsook en el código?

La configuración de Unsook se realiza en un archivo .js, habitualmente ubicado en la carpeta de utilidades del proyecto. A continuación, te explicamos cómo crear y configurar este archivo para manejar migraciones y semillas de datos.

  1. Importación de Unsook: Comenzamos con la importación de Unsook y las utilidades necesarias para establecer nuestras migraciones y datos.

    const Unsook = require('unsook');
    const SQLiteStore = require('unsook-sqlite-store');
    
  2. Creación de instancias: Creamos una nueva instancia de Unsook con la configuración necesaria.

    const unsookInstance = new Unsook({
        migrations: glob.sync('src/db/dataSets/*.js'),
        context: {
            queryInterface: SQLite.getQueryInterface()
        },
        storage: new SQLiteStore(SQLite),
        logger: undefined
    });
    
    • migrations: Define la ruta donde se encuentran las migraciones o los juegos de datos.
    • context: Indica el contexto para correr las migraciones, tomando la QueryInterface de nuestra conexión SQLite.
    • storage: Configuración para utilizar el almacén de datos de SQLite en este contexto.
  3. Ejecución programática de las migraciones: Utilizamos las funciones up y down para aplicar o revertir los cambios en los datos.

    async function applyMigrations() {
        try {
            await unsookInstance.up();
            console.log('Migraciones aplicadas correctamente.');
        } catch (error) {
            console.error('Error al aplicar migraciones:', error);
        }
    }
    
    async function revertMigrations() {
        try {
            await unsookInstance.down();
            console.log('Migraciones revertidas correctamente.');
        } catch (error) {
            console.error('Error al revertir migraciones:', error);
        }
    }
    

¿Cómo manejar los errores comunes al utilizar Unsook?

Si al correr las migraciones encuentras algún error, puede que esté relacionado con la QueryInterface. Es crucial validar si el QueryInterface viene en el contexto correcto. Esto se realiza mediante una simple comprobación:

const queryInterface = context.queryInterface.context ? 
                       context.queryInterface.context : 
                       context.queryInterface;

Asegúrate de agregar esta verificación tanto en el app como en el down para asegurar la compatibilidad en múltiples entornos.

¿Qué ventajas ofrece una configuración programática con Unsook?

Gracias a Unsook, controlas completamente el entorno de prueba. Estableces puntos estratégicos para montar y desmontar la semilla de información. Esto facilita la creación de entornos complejos repletos de productos, órdenes y clientes para pruebas más rigurosas y realistas.

Atrévete a seguir profundizando en herramientas como Unsook que te permitirán escalar tus aplicaciones con más eficacia y robustez. ¡La automatización es un paso crucial hacia entornos de desarrollo y pruebas más competentes!

Aportes 2

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Hola, si de pronto tienen problemas como yo con que umzug no encuentre los seeders, pueden cambiar el enrutamiento con "path": ```js const path = require('path'); const { Umzug, SequelizeStorage } = require('umzug'); const sequelize = require('../../../src/db/sequelize'); const umzug = new Umzug({ migrations: { glob: path.join(__dirname, '../../../src/db/seeders/*.js') }, context: sequelize.getQueryInterface(), storage: new SequelizeStorage({ sequelize }), logger: undefined, }); ``` `const sequelize = require('../../../src/db/sequelize');` `const umzug = new Umzug({  migrations: { glob: path.join(__dirname, '../../../src/db/seeders/*.js') },  context: sequelize.getQueryInterface(),  storage: new SequelizeStorage({ sequelize }),  logger: undefined,});`
Pude resolver mi problema con los puertos (solo tenía que reiniciar los contenedores de docker) y quise hacer el código de la clase un poco más reutilizable. Creé un archivo en la carpeta 'utils' llamado checkQueryInterface.js. Este es el código: ```javascript function CheckQueryInterface(queryInterface) { if (queryInterface.context) { queryInterface = queryInterface.context } return queryInterface} module.exports = { CheckQueryInterface } ``` Y lo podemos usar en 1-users.js por ejemplo de esta forma: ```javascript const bcrypt = require('bcrypt');const { USER\_TABLE } = require('../models/user.model');const { CheckQueryInterface } = require('../../../e2e/utils/checkQueryInterface'); module.exports = { up: async (queryInterface) => { queryInterface = CheckQueryInterface(queryInterface); const password = 'admin123'; const hash = await bcrypt.hash(password, 10); return queryInterface.bulkInsert(USER\_TABLE, \[{ email: '[email protected]', password: hash, role: 'admin', created\_at: new Date(), }]); }, down: (queryInterface) => { queryInterface = CheckQueryInterface(queryInterface); return queryInterface.bulkDelete(USER\_TABLE, null, {}); }}; ```