Conectar Cypress a MySQL sin exponer secretos

Curso de Automatización de Pruebas de Backend con Cypress

Contenido del curso

No sé dónde empezar

Introduccion a la Automatización Backend

Conociendo Cypress

Validando el contenido de la respuesta

Haciendo diferentes tipos de peticiones

Bases de Datos

Prueba en conjunto

15
Prueba de API y base de datos con Cypress
09:08 min

Próximos pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0011:01

Conectar Cypress a MySQL sin exponer secretos

Curso de Automatización de Pruebas de Backend con Cypress

Clase 11 de 17

Clase 11 / 17

Comentarios (15)15 comentarios

Isilreiberth José Pérez Rodríguez

Hace 4 años

Asi seria la conexión mysql + cypress 12:

npm install mysql2 --save-dev

//cypress.config.js
const { defineConfig } = require('cypress');
const mysql = require('mysql2');

function queryTestDB(query) {
  const connection = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '*******',
    database: 'MiDataBase',
  });
  connection.connect();

  return new Promise((resolve, reject) => {
    connection.query(query, (error, results) => {
      if (error) reject(error);
      else {
        connection.end();
        return resolve(results);
      }
    });
  });
}

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on) {
      on('task', {
        queryDB: (query) => {
          return queryTestDB(query);
        },
      });
    },
  },
});


//Test
describe('Haremos una conexión con MySQL', () => {
  it('Debe obtener los resultados de una consulta', () => {
    cy.task('queryDB', 'SELECT * FROM ACTOR').then(
      (result) => {
        expect(result.length).to.equal(4);
      }
    );
  });
});

Diego Vergara

Hace 4 años

Con este código y mysql en un contenedor docker pude correr las pruebas en la version 12, aunque no me cargan las variables de entorno :(.

Config:

const { defineConfig } = require("cypress");
const mysql = require('mysql')

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on, config) {
      on('task',{

        queryTestDb:function(query,config) {
          const connection = mysql.createConnection({
            "user":"root",
            "password":"example",
            "database":"db"
        })
          connection.connect()

          return new Promise((resolve, reject) => {
            connection.query(query,(err,results)=>{
              if(err){
                reject(err)
              } else {

                connection.end()
                return resolve(results)
              }
            })
          })
        }
      })
      // implement node event listeners here
    },
    excludeSpecPattern: [
      "cypress/e2e/getting-started/*.js",
      "cypress/e2e/advanced-examples/*.js",
    ],
    baseUrl:""
  }
});

Create dummy DATABASE

CREATE DATABASE people (id int,name varchar(255));

Test:

describe('testing database', () => {

    it('select',()=>{
        cy.task('queryTestDb',"select * from people").then((response)=>{
            cy.log(response)
        })

    })
})

Nicolas Cardona

Hace 4 años

Buenas Diego, el por qué de que no te trae las variables de entorno es porque la sintaxis queryTestDb: function (query, config) { Debería ser queryTestDb (query) { . Otra cosa, el config no se le debe pasar a esta función ya que el setupNodeEvents(on, config) { lo tiene y está en el mismo closure. Un tanto diferente por el cambio de versión. Espero te sirva.

Fabián Alejandro Oger

Hace 4 años

Ya vi el tema que estás teniendo ahí, te falta el host. En vez de esto:

mysql.createConnection({
            "user":"root",
            "password":"example",
            "database":"db"
        })

Poné esto:

mysql.createConnection({
            "user":"root",
            "password":"example",
            "database":"db"
	    "host":"{completar}"
        })

Emmanuel Rodríguez

Hace 4 años

Prisma ORM con Cypress

. Para este efecto, partimos de que poseemos una abstracción como clase de Prisma o mediante la abstracción del 🔗 Prisma client. . Para poder probar ciertos casos de uso, podemos utilizar los eventos de Cypress mediante 📚 Plugins. Por lo que primero, empezamos a escribir nuestro plugin. .

Nota. Para la versión 10 de Cypresss, la generación de plugins dentro de la carpeta plugin esta descontinuada y soportada en el archivo cypress.config.

. Definiendo nuestro Plugin:

import {defineConfig} from 'cypress'
import Prisma from './src/libs/Prisma'

export default defineConfig({
    e2e: {
        baseUrl: 'URL',
        setupNodeEvents(on, _) {
            on('task', {
                findMany: ({model, query}) => {
                    const client = new Prisma(model)
                    return client.findMany(query)
                },
            })
        }
    }
})

De aquí importa la forma en cómo abstraemos nuestra Librería / ORM / Driver para que según sea el caso, mock o instancia, usemos la definición apropiada. . Luego, escribimos nuestra(s) prueba(s):

interface IPost {
    title: string
    text: string
    author: string
}

const findPosts = (posts: IPost[]) => {
    expect(posts).to.be.an('array')
    expect(posts).to.have.length.of.at.least(1)
    posts.forEach((post: IPost) => {
        expect(post).to.have.property('title')
        expect(post).to.have.property('text')
        expect(post).to.have.property('author')
    })
}

describe("Testing Prisma", () => {
    it("should works to find many posts", function () {
        cy.task("findMany", {model: 'post', query: {}})
            .then((result: any) => findPosts(result));
    });
});

En mi caso, me interesa evaluar el formato de respuesta que me entrega Prisma mediante findMany, lo que me permite evaluar la siguiente estructura de esquema:

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  text      String
  author    String
  createdAt DateTime @default(now())
  updatedAt DateTime @default(now())

  @@map("post")
}

Cristian Urbano

Hace 3 años

El sistema de comentarios esta roto, poprque a 6 personas les parecio util este aporte, nos lo muestra a todos en primer lugar, deberiamos tener un dislike o un ocultar. Para mi, que en estas lecciones se hagan "aportes" que son mas avanzados o incluyen tecnologias o lenguajes que no se vieron en el curso. Confunden y bloquean, no suman. Saludos

Marco Antonio Urquidi Espada

Hace 3 años

Yo siempre refuerzo, lo visto en el video con los comentarios que se tienen y en verdad un 99% aportan algo a lo aprendido, en este caso tendre que concordar con el compa @damsorian.

pero sigan comentando ayuda mucho.... espero algun dia tb dar aportes como los suyos.

Geovanni Atavales Quiroga

Hace 4 años

Si no utilizan recurrentemente MySql, es posible se encuentren con errores varios de configuración. Uno de ellos, y según mi experiencia el más recurrente al inicio, es: "Client does not support authentication protocol requested by server; consider upgrading MySQL client", para corregirslo, solo ejecuten la siguiente query : " ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password'; " en donde deben reemplazar 'password' por la contraseña a usar en las pruebas.

Juan Pablo González

Hace 4 años

Hola, me gustaria que muestrne como configurar la base de datos desde 0 ya que si bien yo tengo el concepto de base de datos es importante que se muestre todo el ciclo de configuración en cypress. Además, recordar que la versión de cypress del curso está desactualizada y debo realizar mucho esfuerzo para poder ver todos los cambios en la nueva versión. El curso de UI me sirvió, pero así con BE no puedo! Me gustaría un poco más de detalle en este sentido.

Mark Joaquin

Hace 4 años

Lo mismo digo, existen vacios al momento de la explicación de nuevos temas.

Mario Alexander Vargas Celis

Hace 2 años

mi codigo:

Diego Fernando Gómez Álvarez

Hace 3 años

Estuve siguiendo el curso pero usando la version 12 de Cypress. Varias cosas cambian entre esta versión y la que se usó en el curso pero los comentarios de los compañeros fueron de mucha ayuda :)

Para las clases que requieren mongodb y mysql utilicé Docker, en el readme dejé algunos comentarios de como crear los contenedores.

https://github.com/difergo/cypressWorkshop

David steven Abril Pulecio

Hace un año

Si no quieren descargar bases de datos en su pc pueden crear y usar una online gratis desde

Pueden usar el codigo de mi repo funcionando en 2025 con cypress version 14

Solo tengan en cuenta que deberan agregar su ip como conexion segura a su base de datos de google cloud, pero es full facil usando su interfaz online.

David101111101/cypress-backend-automation at MySQL

Gabriel Hans González Peña

Hace 4 años

¿Saben como se configura el plugin de base de datos en el cypress versión 10?

Javier Fuentes Mora

Profesor

Hace 4 años

hola es casi lo mismo , solo que se hace desde el config dentro de la propiedad setupNodeEvents

Isilreiberth José Pérez Rodríguez

Hace un año

Así seria la conexión mssql + cypress 15: Espero les sirva:

npm install mssql --save-dev

/////////////////////CONNECTION SQL SERVER/////////////////////////////////////////

//cypress.config.js

const { defineConfig } = require('cypress');

const sql = require('mssql');

async function queryTestDB(query, dbConfig) {

try {

const pool = await sql.connect({

server: dbConfig.server,

port: dbConfig.port,

database: dbConfig.database,

user: dbConfig.user,

password: dbConfig.password,

encrypt: dbConfig.encrypt,

trustServerCertificate: dbConfig.trustServerCertificate,

});

const result = await pool.request().query(query);

console.dir(result);

await sql.close();

return result;

} catch (err) {

throw new Error(Error executing query "${query}": ${err});

}

module.exports = defineConfig({

e2e: {

setupNodeEvents(on, config) {

// Leemos las credenciales desde config.env

const dbConfig = config.env.testing;

on('task', {

queryDB: (query) => queryTestDB(query, dbConfig),

});

return config;

});

//cypress.env.json

{

"testing": {

"server": "xxx.x.x.x",

"port": XXXXX,

"database": "xxx",

"user": "xxxxx",

"password": "xxxxxxxxxxx",

"encrypt": true,

"trustServerCertificate": true

}

Tanisha Salazar

Hace 4 años

¿Lo de la función que se crea para conectarse en la base de datos, se escribe en el archivo de cypress.config.js para cypress 10?

¿El archivo de cyress.env.json funciona en cypress 10?

Javier Fuentes Mora

Profesor

Hace 4 años

asi es es lo mismo :) en el curso avanzado de cypress lo explicare estate atento

Abdul Florez Lopez

Hace 4 años

Como seria esta estructura en Cypress 10?

Javier Fuentes Mora

Profesor

Hace 4 años

Hey esto te puede servir https://docs.cypress.io/guides/references/migration-guide

Juan Morillo

Hace 3 años

No olviden agregar en las credenciales para conectarse a la base de datos mysql el "port" = "XXXX" en mi caso uso un puerto diferente al 3306 y daba un AggregatedError a la hora de correr la prueba

Luis Alberto Juarez Corona

Hace 2 años

En el archivo cypress.config.js

Nicolas Cardona

Hace 4 años

¡Hola! La razón de que no carga las variables de entorno es porque el config del callback setNodeEvents está vacío. ¿Saben por qué?

Recursos

Probar bases de datos relacionales desde Cypress te permite validar que tus queries funcionan correctamente sin exponer credenciales en tu repositorio. Aquí aprenderás a configurar un plugin con la librería MySQL, conectar tu base de datos relacional y ejecutar tu primer select desde una prueba automatizada, ideal si trabajas con QA automation o testing de integración.

¿Cómo instalar y configurar la librería MySQL en Cypress?

El primer paso es instalar la librería MySQL en tu proyecto, ya que será la encargada de abrir la conexión y ejecutar los queries contra tu base de datos relacional [00:35].

Una vez instalada, abre el archivo index.js dentro de la carpeta de plugins e importa la librería con const mysql = require('mysql'). Este archivo es el puente entre Cypress y servicios externos como bases de datos.

¿Por qué usar un plugin en Cypress para conectar a MySQL? Porque Cypress corre en el navegador y no puede ejecutar conexiones directas a bases de datos. Los plugins viven en Node, así que ahí sí puedes abrir conexiones, ejecutar queries y devolver resultados a tus tests.

¿Cómo crear la función queryTestDb?

Antes del module.exports, declara una función llamada queryTestDb que reciba dos parámetros: el query y la config [02:05]. Dentro de esa función:

Crea la conexión con mysql.createConnection(config.env.db).
Llama a connection.connect() para abrir el canal.
Retorna una nueva promesa con resolve y reject como parámetros del callback.
Ejecuta connection.query(query, (error, results) => {...}).
Si hay error, rechaza la promesa con reject(error).
Si no, cierra la conexión con connection.end() y resuelve con resolve(results).

Cerrar la conexión después de cada query es clave: evita dejar conexiones abiertas que saturen tu base de datos.

¿Cómo registrar el plugin con on task en Cypress?

Dentro del module.exports, usa on('task', {...}) para registrar una tarea llamada queryDb [04:10]. Esta tarea recibe el query como parámetro y retorna la función queryTestDb(query, config).

El objeto config lo provee Cypress automáticamente cuando ejecuta los plugins, así que no necesitas pasarlo manualmente. Esto te permite invocar tu plugin desde cualquier test usando cy.task('queryDb', 'tu query').

¿Cómo proteger credenciales con cypress.env.json?

Guardar credenciales directamente en cypress.json no es seguro porque ese archivo suele estar versionado. La solución es crear en la raíz del proyecto un archivo llamado cypress.env.json y agregarlo a tu .gitignore [05:20].

¿Qué es cypress.env.json y para qué sirve? Es un archivo de variables de entorno que Cypress lee automáticamente y expone en config.env. Lo usas para guardar secretos como hosts, usuarios o contraseñas sin subirlos a tu repositorio.

La estructura del archivo debe seguir el formato que la librería MySQL espera para crear conexiones:

{ "db": { "host": "tu_host", "user": "tu_usuario", "password": "tu_password", "database": "tu_base_de_datos" } }

La propiedad db es arbitraria, tú decides cómo nombrarla, pero debe coincidir con la forma en que la accedes desde el plugin: config.env.db. Si la nombras aaa, así tienes que invocarla en ambos lados.

¿Por qué usar host, user, password y database?

Porque esa es la estructura exacta que la librería MySQL espera para abrir una conexión. Si te has conectado antes a una base de datos relacional, este formato te resultará familiar. Cualquier campo extra o mal nombrado provocará que la conexión falle.

¿Cómo ejecutar tu primera prueba contra la base de datos?

Crea un archivo llamado bd.spec.js dentro de la carpeta de tests [07:45]. Dentro escribe un bloque describe con el título "Pruebas a base de datos" y un it que pruebe un select.

Dentro del test, invoca el plugin así:

javascript cy.task('queryDb', 'select * from pruebas').then((results) => { console.log(results); });

Guarda los cambios, abre Cypress y ejecuta la prueba. Si todo está configurado correctamente, verás que la prueba pasa exitosamente, te regresa un arreglo (vacío si la tabla no tiene datos) y no lanza ningún error.

¿Qué hace cy.task en Cypress? Es el método que dispara una tarea registrada en los plugins. Le pasas el nombre de la tarea y los parámetros, y recibes en el then lo que la promesa resuelva, en este caso los resultados del query.

¿Qué validaste con esta configuración?

Que la librería MySQL se conecta correctamente con las credenciales de cypress.env.json.
Que el plugin queryDb ejecuta queries y devuelve resultados.
Que las variables de entorno protegen tus secretos del repositorio.
Que un select básico funciona como punto de partida para pruebas más complejas.

En la siguiente clase llevarás esto al siguiente nivel probando insert y delete, para validar que tu plugin soporta cualquier tipo de consulta que necesites lanzar contra tu base de datos. ¿Tú cómo proteges las credenciales de tus pruebas? Cuéntame en los comentarios.

//cypress.config.js
const { defineConfig } = require('cypress');
const mysql = require('mysql2');

function queryTestDB(query) {
  const connection = mysql.createConnection({
    host: 'localhost',
    user: 'root',
    password: '*******',
    database: 'MiDataBase',
  });
  connection.connect();

  return new Promise((resolve, reject) => {
    connection.query(query, (error, results) => {
      if (error) reject(error);
      else {
        connection.end();
        return resolve(results);
      }
    });
  });
}

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on) {
      on('task', {
        queryDB: (query) => {
          return queryTestDB(query);
        },
      });
    },
  },
});


//Test
describe('Haremos una conexión con MySQL', () => {
  it('Debe obtener los resultados de una consulta', () => {
    cy.task('queryDB', 'SELECT * FROM ACTOR').then(
      (result) => {
        expect(result.length).to.equal(4);
      }
    );
  });
});

const { defineConfig } = require("cypress");
const mysql = require('mysql')

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on, config) {
      on('task',{

        queryTestDb:function(query,config) {
          const connection = mysql.createConnection({
            "user":"root",
            "password":"example",
            "database":"db"
        })
          connection.connect()

          return new Promise((resolve, reject) => {
            connection.query(query,(err,results)=>{
              if(err){
                reject(err)
              } else {

                connection.end()
                return resolve(results)
              }
            })
          })
        }
      })
      // implement node event listeners here
    },
    excludeSpecPattern: [
      "cypress/e2e/getting-started/*.js",
      "cypress/e2e/advanced-examples/*.js",
    ],
    baseUrl:""
  }
});

import {defineConfig} from 'cypress'
import Prisma from './src/libs/Prisma'

export default defineConfig({
    e2e: {
        baseUrl: 'URL',
        setupNodeEvents(on, _) {
            on('task', {
                findMany: ({model, query}) => {
                    const client = new Prisma(model)
                    return client.findMany(query)
                },
            })
        }
    }
})

interface IPost {
    title: string
    text: string
    author: string
}

const findPosts = (posts: IPost[]) => {
    expect(posts).to.be.an('array')
    expect(posts).to.have.length.of.at.least(1)
    posts.forEach((post: IPost) => {
        expect(post).to.have.property('title')
        expect(post).to.have.property('text')
        expect(post).to.have.property('author')
    })
}

describe("Testing Prisma", () => {
    it("should works to find many posts", function () {
        cy.task("findMany", {model: 'post', query: {}})
            .then((result: any) => findPosts(result));
    });
});

model Post {
  id        Int      @id @default(autoincrement())
  title     String
  text      String
  author    String
  createdAt DateTime @default(now())
  updatedAt DateTime @default(now())

  @@map("post")
}

Resumen

¿Cómo instalar y configurar la librería MySQL en Cypress?

El primer paso es instalar la librería MySQL en tu proyecto, ya que será la encargada de abrir la conexión y ejecutar los queries contra tu base de datos relacional [00:35].

¿Por qué usar un plugin en Cypress para conectar a MySQL? Porque Cypress corre en el navegador y no puede ejecutar conexiones directas a bases de datos. Los plugins viven en Node, así que ahí sí puedes abrir conexiones, ejecutar queries y devolver resultados a tus tests.

¿Cómo crear la función queryTestDb?

Antes del module.exports, declara una función llamada queryTestDb que reciba dos parámetros: el query y la config [02:05]. Dentro de esa función:

Crea la conexión con mysql.createConnection(config.env.db).
Llama a connection.connect() para abrir el canal.
Retorna una nueva promesa con resolve y reject como parámetros del callback.
Ejecuta connection.query(query, (error, results) => {...}).
Si hay error, rechaza la promesa con reject(error).
Si no, cierra la conexión con connection.end() y resuelve con resolve(results).

Cerrar la conexión después de cada query es clave: evita dejar conexiones abiertas que saturen tu base de datos.

¿Cómo registrar el plugin con on task en Cypress?

Dentro del module.exports, usa on('task', {...}) para registrar una tarea llamada queryDb [04:10]. Esta tarea recibe el query como parámetro y retorna la función queryTestDb(query, config).

¿Cómo proteger credenciales con cypress.env.json?

¿Qué es cypress.env.json y para qué sirve? Es un archivo de variables de entorno que Cypress lee automáticamente y expone en config.env. Lo usas para guardar secretos como hosts, usuarios o contraseñas sin subirlos a tu repositorio.

La estructura del archivo debe seguir el formato que la librería MySQL espera para crear conexiones:

{ "db": { "host": "tu_host", "user": "tu_usuario", "password": "tu_password", "database": "tu_base_de_datos" } }

¿Por qué usar host, user, password y database?

¿Cómo ejecutar tu primera prueba contra la base de datos?

Crea un archivo llamado bd.spec.js dentro de la carpeta de tests [07:45]. Dentro escribe un bloque describe con el título "Pruebas a base de datos" y un it que pruebe un select.

Dentro del test, invoca el plugin así:

javascript cy.task('queryDb', 'select * from pruebas').then((results) => { console.log(results); });

¿Qué hace cy.task en Cypress? Es el método que dispara una tarea registrada en los plugins. Le pasas el nombre de la tarea y los parámetros, y recibes en el then lo que la promesa resuelva, en este caso los resultados del query.

¿Qué validaste con esta configuración?

Que la librería MySQL se conecta correctamente con las credenciales de cypress.env.json.
Que el plugin queryDb ejecuta queries y devuelve resultados.
Que las variables de entorno protegen tus secretos del repositorio.
Que un select básico funciona como punto de partida para pruebas más complejas.

Introduccion a la Automatización Backend

Pruebas de backend con Cypress desde cero

Qué es el backend testing y sus conceptos clave

DevTools y Postman para probar APIs

Conociendo Cypress

Cypress y JSON Server para pruebas de API

Validar headers con cy.request en Cypress

Validar status codes 200 y 404 en Cypress

Validando el contenido de la respuesta

Validar body, headers y status con Cypress

Validar status code y mensaje de error en Cypress

Haciendo diferentes tipos de peticiones

Flujo POST, PUT y DELETE con cy.request

Cómo testear una GraphQL API con Cypress

Bases de Datos

Conectar Cypress a MySQL sin exponer secretos

INSERT, SELECT y DELETE en Cypress con MySQL

Cómo probar MongoDB con Cypress

Crear e insertar registros en MongoDB con Cypress

Prueba en conjunto

Prueba de API y base de datos con Cypress

Próximos pasos

Qué hacer al terminar un curso online

Automatización de Pruebas con Cypress

Conectar Cypress a MySQL sin exponer secretos

Progreso del curso

Introduccion a la Automatización Backend

Conociendo Cypress

Validando el contenido de la respuesta

Haciendo diferentes tipos de peticiones

Bases de Datos

Prueba en conjunto

Próximos pasos

Recursos

Recursos