GitHub Actions es la plataforma de integración continua integrada en GitHub: permite que un conjunto de tareas —entre ellas, tus pruebas— se ejecute automáticamente cuando pasa algo en el repositorio, como subir código o abrir una solicitud de cambios. Se configura con un archivo YAML de flujo de trabajo (workflow) dentro de .github/workflows/, que define cuándo se dispara (el evento, por ejemplo push o pull_request), dónde corre (una máquina virtual, el runner) y qué hace (los pasos: instalar dependencias, correr las pruebas). Lo que cambia el juego: si una prueba falla, el flujo falla, y eso frena el cambio antes de que se integre —una solicitud con pruebas rotas no se puede fusionar—. Las credenciales van en secretos cifrados, nunca en el archivo. Es la pieza que convierte «tengo pruebas» en «mis pruebas protegen el proyecto».
Ver índice de contenidos
Qué es la integración continua
La integración continua (CI, por continuous integration) es la práctica de comprobar automáticamente cada cambio en cuanto se sube, en vez de esperar a juntar muchos y revisarlos al final. La idea de fondo: los problemas se encuentran antes, cuando el cambio es pequeño y reciente, y por lo tanto son más baratos de arreglar.
El cambio de mentalidad
Una prueba que corrés vos, a veces, en tu máquina depende de que te acuerdes y de que tu entorno esté bien. Una prueba que corre sola, siempre, en un entorno limpio, con cada cambio no depende de nadie: es una red de seguridad que está puesta todo el tiempo. GitHub Actions es lo que da ese salto, y su mayor valor no es la comodidad sino la consistencia: nadie puede «olvidarse» de correr las pruebas.
Anatomía de un flujo de trabajo
Un flujo de trabajo es un archivo YAML dentro de .github/workflows/. Su estructura mínima para correr pruebas:
# .github/workflows/pruebas.yml
name: Pruebas
# CUÁNDO: se dispara al subir código y al abrir solicitudes de cambio.
on:
push:
branches: [ main ]
pull_request:
jobs:
test:
# DÓNDE: una máquina virtual limpia que provee GitHub.
runs-on: ubuntu-latest
steps:
# QUÉ: los pasos, en orden.
- uses: actions/checkout@v4 # baja el código
- uses: actions/setup-node@v4 # prepara el entorno
with:
node-version: '20'
- run: npm ci # instala dependencias
- run: npm test # corre las pruebasSe lee de arriba abajo: cuándo (el bloque on), dónde (runs-on, el ejecutor) y qué (los steps). Cada paso es una acción reutilizable ya publicada (como checkout, que descarga el código) o un comando de terminal directo (run). El archivo vive dentro del repositorio, versionado junto al código, así que las reglas de qué se comprueba evolucionan con el proyecto.
Cuándo se dispara
El bloque on define los eventos que ejecutan el flujo. Los dos más importantes para pruebas:
| Evento | Cuándo ocurre | Para qué sirve |
|---|---|---|
push | Al subir código a una rama | Comprobar cada cambio que llega a la rama principal |
pull_request | Al abrir o actualizar una solicitud de cambios | Comprobar el cambio antes de fusionarlo. El más valioso |
schedule | En un horario fijo | Pruebas largas que no conviene correr en cada cambio |
workflow_dispatch | A mano, con un botón | Lanzar el flujo cuando lo necesites |
El evento estrella es pull_request, porque comprueba el cambio antes de que se integre a la rama principal. Eso permite lo más útil de todo: exigir que las pruebas pasen como condición para fusionar.
Frenar lo que rompe
Acá está el valor real, y no es «ver que las pruebas fallaron»: es impedir que el cambio roto avance. Cada paso del flujo tiene éxito o falla según su código de salida; si un paso falla —por ejemplo, npm test devuelve error porque una prueba no pasó—, el flujo entero se marca como fallido.
Combinado con las reglas de protección de rama de GitHub, eso se vuelve una barrera: se configura la rama principal para exigir que el flujo pase antes de permitir la fusión. Con eso:
- Una solicitud de cambios con pruebas rotas no se puede fusionar. El botón queda bloqueado hasta que se arregle.
- El código que rompe algo no llega a la rama de la que sale producción.
- La revisión humana se concentra en lo que importa, porque lo mecánico ya lo verificó la máquina.
Esta es la diferencia entre tener pruebas y que las pruebas protejan. Qué conviene ejecutar en esta barrera —rápido y confiable— y qué dejar para flujos programados más lentos es una decisión de estrategia de prueba: un pipeline que tarda una hora en cada cambio termina saboteado.
Ver los resultados
Cuando un flujo falla, hace falta saber por qué sin adivinar. GitHub Actions ayuda de varias formas:
- Registros por paso. Cada paso muestra su salida; el que falló queda marcado, y ahí está el error.
- Artefactos. Se pueden guardar archivos que produce la ejecución —reportes de pruebas, capturas de una regresión visual fallida, el reporte HTML de Newman— para descargarlos y revisarlos.
- Estado visible en la solicitud. La tilde verde o la cruz roja aparecen en la propia solicitud de cambios, así que quien revisa ve de un vistazo si está lista.
Cuando el flujo necesita credenciales —un token para desplegar, una clave de un servicio—, nunca se escriben en el archivo YAML, que está versionado y a la vista. Van en los secretos del repositorio: GitHub los guarda cifrados y los inyecta como variables solo en el momento de la ejecución. Es la misma regla que en cualquier lado: las credenciales no viven en el código.
Errores frecuentes
- Tener el flujo pero no proteger la rama. Sin la regla de protección, un cambio roto se fusiona igual: el flujo solo avisa, no frena.
- Meter todo en el pipeline de cada cambio. Un flujo lento termina saboteado; las pruebas largas van a un flujo programado.
- Escribir credenciales en el YAML. El archivo está versionado y visible; las credenciales van en secretos.
- Depender del entorno local. El ejecutor es una máquina limpia; si la prueba necesitaba algo de tu equipo, falla.
- No fijar versiones. Un flujo que instala «lo último» sin fijar versión se rompe cuando algo cambia río arriba.
- Ignorar los flujos que fallan. Un pipeline en rojo que nadie mira es peor que no tenerlo: da falsa sensación de red.
- No guardar artefactos de los fallos. Sin el reporte o la captura, diagnosticar un fallo remoto es a ciegas.
Preguntas frecuentes
¿Qué es la integración continua y por qué me conviene?
La integración continua es la práctica de comprobar automáticamente cada cambio en cuanto se sube al repositorio, en lugar de acumular muchos cambios y revisarlos juntos al final. Te conviene porque encuentra los problemas cuando son pequeños y recientes, que es cuando más baratos y fáciles resultan de arreglar. El cambio de fondo respecto de correr las pruebas a mano es la consistencia: una prueba que ejecutás vos, a veces, en tu máquina, depende de que te acuerdes y de que tu entorno esté bien configurado; una prueba que corre sola, siempre, en un entorno limpio y con cada cambio, no depende de nadie y está puesta como red de seguridad todo el tiempo. Nadie puede olvidarse de correrla, y eso es justamente lo que la hace confiable.
¿Qué es un flujo de trabajo o workflow?
Es el archivo que define qué tareas automáticas se ejecutan y cuándo. En GitHub Actions es un archivo en formato YAML que vive dentro del repositorio, en una carpeta reservada para flujos, y tiene tres partes esenciales. La primera define cuándo se dispara, mediante los eventos del repositorio como subir código o abrir una solicitud de cambios. La segunda define dónde corre, especificando un ejecutor, que es una máquina virtual limpia que provee GitHub. Y la tercera define qué hace, mediante una secuencia de pasos que se ejecutan en orden: descargar el código, preparar el entorno, instalar dependencias y correr las pruebas. Cada paso puede ser una acción reutilizable ya publicada o un comando de terminal directo. Como el archivo está versionado junto al código, las reglas evolucionan con el proyecto.
¿Cómo hago que un cambio con pruebas rotas no se pueda fusionar?
Combinando dos cosas. Primero, un flujo que corra las pruebas ante el evento de solicitud de cambios, de modo que cada solicitud se compruebe antes de integrarse; como los pasos fallan según su código de salida, si una prueba no pasa el flujo entero queda marcado como fallido. Segundo, y esto es lo que realmente frena, las reglas de protección de rama de GitHub: se configura la rama principal para exigir que ese flujo pase como condición obligatoria para permitir la fusión. Con las dos cosas activas, una solicitud con pruebas rotas deja el botón de fusionar bloqueado hasta que se arregle, y el código que rompe algo no llega a la rama de la que sale producción. Sin la regla de protección, el flujo solo avisa del fallo pero no impide integrar el cambio.
¿Dónde pongo las credenciales que necesita el flujo?
En los secretos del repositorio, nunca en el archivo del flujo. El archivo YAML está versionado y a la vista de cualquiera con acceso al código, así que escribir ahí un token o una contraseña equivale a publicarlos. GitHub ofrece un almacén de secretos cifrados en la configuración del repositorio: se guardan ahí y el flujo los referencia por su nombre, de modo que GitHub los inyecta como variables solo en el momento de la ejecución, sin exponer su valor en los registros. Es exactamente la misma regla que rige en cualquier parte del desarrollo: las credenciales no viven en el código ni en los archivos versionados, sino en un mecanismo aparte pensado para protegerlas. Tratar los secretos así desde el principio evita filtraciones que después son muy difíciles de revertir.
¿Qué pruebas conviene correr en el pipeline?
Las que sean rápidas y confiables, para que el pipeline de cada cambio dé una respuesta pronta sin volverse un estorbo. Las pruebas unitarias y de integración rápidas, y comprobaciones como las de API o accesibilidad, encajan bien en el flujo que se dispara con cada cambio. Las pruebas lentas o costosas —suites completas de interfaz, pruebas sobre muchos navegadores o dispositivos, pruebas de rendimiento— conviene moverlas a un flujo programado que corra en horarios fijos, para no frenar cada cambio con una espera larga. La razón es práctica: un pipeline que tarda una hora en responder termina saboteado, la gente busca formas de saltárselo y deja de cumplir su función. Decidir qué va en la barrera rápida y qué en los flujos lentos es parte de la estrategia de pruebas del proyecto.
¿GitHub Actions sirve solo para pruebas?
No, sirve para automatizar cualquier tarea que se dispare por un evento del repositorio, aunque ejecutar pruebas es uno de sus usos más frecuentes y el que cubre esta guía. Con la misma mecánica de flujos, eventos y pasos se pueden automatizar despliegues, publicación de paquetes, generación de documentación, revisiones de estilo de código, análisis de seguridad y muchas otras tareas, encadenando la integración continua con la entrega continua. En el mundo DevOps, esos flujos de construcción, prueba y despliegue combinados son lo que se llama un pipeline de CI/CD. Para el enfoque de pruebas, lo importante es dominar primero el patrón básico —correr las pruebas con cada cambio y frenar lo que rompe—, y desde ahí el resto de las automatizaciones son variaciones del mismo esquema.
Fuentes
Documentación oficial y material de la comunidad consultados para esta guía. Fecha de consulta: 28 de julio de 2026.
Aportes de la comunidad Underc0de
- Underc0de, foro. Sección QA (Quality Assurance). Consultas sobre automatización de pruebas e integración continua.
- Underc0de, foro. Sección Programación. Flujos de trabajo, Git y automatización de proyectos.
Documentación oficial
- GitHub. GitHub Actions documentation. La documentación oficial de la plataforma de integración continua, citada en la guía.
- GitHub. Workflow syntax. La sintaxis del archivo de flujo de trabajo YAML.
- GitHub. Events that trigger workflows. Qué eventos disparan un flujo, como push o pull request.
- GitHub. Encrypted secrets. Cómo manejar credenciales en los flujos sin exponerlas.