Smoke testing, sanity testing y pruebas de regresión: cuál ejecutar y cuándo
Smoke testing, sanity testing y pruebas de regresión: qué comprueba cada una, cuándo ejecutarla y cómo ejecutar las tres con las mismas pruebas grabadas.
El smoke testing comprueba que una compilación nueva arranca y que sus funciones principales responden. El sanity testing comprueba a fondo una corrección o un cambio. Las pruebas de regresión comprueban que no se ha roto nada de lo que antes funcionaba. Se diferencian en amplitud, profundidad y momento.
La mayoría de los equipos conoce los tres nombres y aun así hace los tres a mano, cuando hay tiempo. Cuando una versión va con retraso, la larga pasada de regresión es lo primero que se recorta, y un error antiguo reaparece delante de un cliente.
Smoke testing, sanity testing y pruebas de regresión: la respuesta corta
Imagine su aplicación como una cuadrícula: sus funciones de izquierda a derecha, y la profundidad con la que se prueba cada una de arriba abajo. Los tres tipos de prueba iluminan partes distintas de esa cuadrícula.
Smoke testing
Amplio y superficial
¿Merece la pena probar esta compilación?
Sanity testing
Estrecho y profundo
¿Funciona esta corrección?
Pruebas de regresión
Amplias y profundas
¿Se rompió algo más?
¿Qué es el smoke testing (pruebas de humo)?
Definición
El smoke testing, o pruebas de humo, es un conjunto corto de pruebas que comprueba si una compilación nueva es lo bastante estable como para probarla.
- Arranca la aplicación y toca una vez cada función principal: la aplicación se abre, un usuario puede iniciar sesión, las pantallas principales se cargan, la acción clave responde.
- No se fija en los detalles.
Una compilación que no supera su smoke test vuelve de inmediato a los desarrolladores, y nadie pierde un día probándola.
Un smoke test también se llama prueba de verificación de compilación, en inglés build verification test, porque se ejecuta justo después de crear una compilación. Su valor es su rapidez: unos minutos, en cada compilación, con un sí o un no claro al final.
¿Qué es el sanity testing (pruebas de cordura)?
Definición
El sanity testing, o pruebas de cordura, es una comprobación rápida y estrecha de que una corrección o un cambio pequeño funciona, y de que la parte de la aplicación que lo rodea sigue comportándose con sensatez.
- Se ejecuta sobre una compilación que trae la corrección de un error o un cambio pequeño.
- Profundiza en esa única zona y deja el resto como está.
Cuando se supera, la compilación merece la ejecución de regresión, que es más larga.
Hecho a mano, un sanity check suele improvisarse: el tester hace clic alrededor de la zona corregida, de memoria. Es rápido, pero no deja constancia de lo que se miró, y dos testers rara vez miran lo mismo.
¿Qué son las pruebas de regresión?
Definición
Las pruebas de regresión vuelven a ejecutar las pruebas existentes después de un cambio, para comprobar que no se ha roto nada de lo que ya funcionaba.
- Son amplias y profundas: cada flujo importante, con sus resultados comprobados.
- Son las más largas de las tres, y por eso se ejecutan por la noche o antes de una versión.
Este artículo lo resume a propósito.La guía completa, con los tipos de pruebas de regresión y lo que debe entrar en una suite, es qué son las pruebas de regresión.
Smoke testing, sanity testing y pruebas de regresión, comparados
| Qué comparar | Smoke testing | Sanity testing | Pruebas de regresión |
|---|---|---|---|
| La pregunta que hace | ¿Merece la pena probar esta compilación? | ¿Funciona esta corrección? | ¿Se rompió algo más? |
| Amplitud | Toda la aplicación | Una función o una corrección | Toda la aplicación |
| Profundidad | Superficial: un toque por función | Profunda, en un solo lugar | Profunda, allí donde importa |
| Cuándo se ejecuta | En cada compilación | Después de una corrección o un cambio pequeño | Cada noche y antes de una versión |
| Cuánto tarda | Unos minutos | Unos minutos | Una hora o más, sin nadie delante |
| Qué significa un fallo | La compilación se rechaza | La corrección vuelve atrás | Una regresión se detecta antes de que la vean los usuarios |
El smoke testing y el sanity testing son la pareja que más se confunde. La manera de distinguirlos es lo que miran: un smoke test mira toda la compilación, un sanity test mira un solo cambio.
Cuál ejecutar, y en qué momento de una versión
Los tres no son rivales. Cada uno tiene su momento en una versión, y cada uno decide si merece la pena ejecutar el siguiente.
Cada compilación
Suite de humo
Unas pocas pruebas cortas, unos minutos. Un fallo rechaza la compilación.
Después de una corrección o un cambio pequeño
Sanity check
La prueba que cubre la corrección, ejecutada de nuevo, con su resultado comprobado.
Cada noche, y antes de una versión
Suite de regresión
Todas las pruebas, sin nadie delante. El informe se lee por la mañana.
El orden es siempre el mismo.
- Primero el smoke testing: si la compilación no puede arrancar o iniciar la sesión de un usuario, no merece la pena ejecutar nada más.
- Después el sanity testing: si la corrección no funciona, la compilación vuelve atrás antes de la ejecución larga.
- Por último la regresión: cuando la compilación es estable y la corrección es correcta, se comprueba todo lo demás.
Una semana, una aplicación: los tres en la práctica
Las cifras de abajo son una ilustración, con números redondos.
| Cuándo | Qué se ejecutó | Qué encontró |
|---|---|---|
| Lunes, llega una compilación nueva | La suite de humo: iniciar sesión, abrir un cliente, crear una factura, exportarla. Cinco pruebas, cuatro minutos. | Todas se superan. Merece la pena probar la compilación. |
| Martes, se corrige un error de redondeo en el impuesto | Un sanity check: la prueba de la factura ejecutada de nuevo, con su total comprobado. | Se supera. La corrección funciona. |
| Martes por la noche | La suite de regresión: las cuarenta pruebas. | Una falla: el total de una nota de crédito es incorrecto. La corrección le afectó. |
El error de la nota de crédito lo encuentra un informe el miércoles por la mañana, no un cliente tres semanas después. Sin la ejecución nocturna, la corrección se habría publicado con él.
Por qué las pruebas de regresión son lo primero que se salta
Hechos a mano, los tres compiten por las mismas horas.
- Una pasada de smoke en cada compilación aparta a un tester de las pruebas de verdad varias veces al día.
- Un sanity check hecho de memoria no deja rastro de lo que se miró.
- Una pasada completa de regresión lleva días, así que se reduce a las pantallas que alguien recuerda cuando la versión va con retraso.
- Los errores que reaparecen están en las pantallas para las que nadie tuvo tiempo.
Nadie decide saltarse las pruebas de regresión. Se van quedando sin sitio, una versión con retraso tras otra.
Automatizar los tres con un framework con código como Selenium o Playwright traslada el trabajo a los programadores: alguien escribe los scripts, los marca como smoke o regresión en el código y los repara cada vez que cambia una pantalla.Los testers que mejor conocen el producto no pueden tocarlos.Pruebas manuales frente a pruebas automatizadas analiza ese intercambio en detalle.
Con pruebas grabadas, los tres son las mismas pruebas, agrupadas de otra manera
GUI Test Studio automatiza pruebas de extremo a extremo de cualquier aplicación sin código. Usted hace un flujo una vez en su aplicación mientras GUI Test Runner-Recorder lo graba, y después la prueba se reproduce sola: los mismos pasos, en el mismo orden, en cada ejecución.
Cuando sus flujos son pruebas grabadas, smoke, sanity y regresión dejan de ser tres trabajos distintos. Son tres maneras de agrupar y ejecutar los mismos archivos de prueba.
Suite de humo
3 de 6 pruebas
En cada compilación
Sanity check
1 de 6 pruebas
Después de una corrección en el pago
Suite de regresión
6 de 6 pruebas
Cada noche
| Tipo de ejecución | Qué es, con pruebas grabadas | Cómo se ejecuta |
|---|---|---|
| Suite de humo | Unas pocas pruebas cortas, una por función principal. | Con gtr-cli, en cada compilación. |
| Sanity check | La única prueba que cubre la corrección, ejecutada de nuevo. | Con Ejecutar prueba, o desde la mitad de la prueba. |
| Suite de regresión | Todas las pruebas que tenga. | Con gtr-cli, cada noche y antes de una versión. |
Tres cosas hacen que las mismas pruebas sirvan en los tres papeles.
- Cada comprobación espera lo que debe encontrar y sigue adelante en cuanto está ahí, así que una prueba corta sigue siendo corta.
- Un grupo de pasos como Iniciar sesión es un escenario que otras pruebas reutilizan, así que se graba una sola vez.
- El GTS Engine encuentra cada elemento primero mediante la información de accesibilidad de la aplicación y visualmente cuando la aplicación no dice nada, así que una prueba sobrevive a los pequeños cambios de la pantalla.
Por qué una comprobación que espera es mejor que una pausa de duración fija se explica en las pausas fijas en las pruebas, y Escenarios muestra cómo los pasos de una prueba se reutilizan en otra.
Un sanity check no tiene por qué reproducir una prueba larga desde el principio.En GUI Test Studio, coloque el cabezal de reproducción donde empieza la parte corregida y elija Guardar y ejecutar desde el cabezal de reproducción: con la aplicación puesta en el estado que tenía en ese momento, solo se ejecutan los pasos a partir de ahí.Ejecutar una prueba lo explica.
Cómo montar una suite de humo y una suite de regresión con las mismas pruebas
Todo el montaje son seis pasos pequeños, y el primero es el único que lleva tiempo de verdad.
- 1
Grabar cada flujo una vez
Haga clic en Grabar en GUI Test Runner-Recorder y haga el flujo en su aplicación, como lo haría un usuario. Cada flujo que importa se convierte en un archivo de prueba, con comprobaciones de lo que mostró la pantalla.
- 2
Compartir los pasos comunes como un escenario
Agrupe los pasos con los que empieza cada prueba, como el inicio de sesión, en un escenario llamado Iniciar sesión. Añada esa prueba a las demás como escenario, para que el inicio de sesión se grabe una vez y se reutilice.
- 3
Elegir los smoke tests
Elija una prueba corta por función principal: la aplicación se abre, un usuario inicia sesión, la pantalla principal se carga, la acción clave responde. Guarde sus archivos de prueba juntos en una carpeta, por ejemplo tests\smoke.
- 4
Guardar las pruebas más profundas en una segunda carpeta
Ponga todas las demás pruebas en una carpeta como tests\regression. La suite de regresión son las dos carpetas juntas: todas las pruebas que tenga.
- 5
Ejecutar el smoke en cada compilación y todo por la noche
En la máquina de compilación, gtr-cli ejecuta la carpeta smoke después de cada compilación y las dos carpetas cada noche. Una prueba fallida hace fallar la compilación, y cada ejecución conserva su informe, su vídeo y sus imágenes.
- 6
Después de una corrección, volver a ejecutar una prueba
Abra la prueba que cubre la corrección y haga clic en Ejecutar prueba: ese es su sanity check. En una prueba larga, inicie la ejecución desde el cabezal de reproducción en GUI Test Studio, con la aplicación puesta en el estado que tenía en ese momento.
Ejecutar los smoke tests en cada compilación y las pruebas de regresión cada noche
En una máquina de compilación, gtr-cli ejecuta pruebas desde la línea de comandos en cualquier herramienta de CI/CD. Acepta archivos de prueba, carpetas y patrones, tantos como usted indique. Una carpeta ejecuta los archivos de prueba que contiene.
gtr-cli run tests\smoke --countdown 0 --junit results\smoke.xml
gtr-cli run tests\smoke tests\regression --countdown 0 --junit results\regression.xml- La primera línea pertenece al trabajo de compilación, y una prueba fallida hace fallar la compilación mediante el código de salida.
- La segunda línea pertenece a un trabajo nocturno.
- Cada ejecución escribe un archivo de resultados que su herramienta de CI lee, y conserva su informe de confianza, su vídeo y sus imágenes.
Por la mañana, una prueba de regresión fallida se lee, no se adivina: el informe de confianza muestra el paso que falló, lo esperado junto a lo encontrado y el historial de las ejecuciones anteriores.Cómo leer un informe de pruebas muestra qué mirar primero, y Ejecutar pruebas en su pipeline enumera todas las opciones de gtr-cli.
Lo que debe saber antes de empezar
| Límite | Lo que significa |
|---|---|
| Una ejecución usa la pantalla real | Las pruebas se ejecutan una tras otra en una máquina, salvo que una prueba web se ejecute sin ventana de navegador. Dé a la ejecución nocturna de regresión una máquina de compilación que nadie esté usando. |
| El mismo punto de partida | Una prueba se reproduce a partir del estado en el que se grabó. Cada suite debe devolver la aplicación a ese estado, y una prueba web abre su propia ventana de navegador limpia. |
| Una prueba comprueba lo que se le pidió comprobar | Una suite de humo en verde dice que las funciones principales responden. No dice que cada detalle sea correcto: ese es el trabajo de la suite de regresión. |
Lo esencial
- 1El smoke testing es amplio y superficial. Decide en minutos si merece la pena probar una compilación.
- 2El sanity testing es estrecho y profundo. Confirma una corrección antes de que empiece la ejecución larga.
- 3Las pruebas de regresión son amplias y profundas. Demuestran que el cambio no rompió nada de lo que funcionaba.
- 4Cada uno tiene su momento: smoke en cada compilación, sanity después de una corrección, regresión cada noche y antes de una versión.
- 5Con pruebas grabadas, son un único conjunto de archivos de prueba. GUI Test Studio los agrupa y los ejecuta de tres maneras, sin código.
Preguntas
¿Cuál es la diferencia entre smoke testing y sanity testing?
El smoke testing comprueba toda la compilación de forma superficial, para decidir si es lo bastante estable como para probarla. El sanity testing comprueba a fondo una corrección o un cambio pequeño. El smoke va primero, en cada compilación, y el sanity sigue a una compilación que trae una corrección.
¿Cuál es la diferencia entre smoke testing y pruebas de regresión?
El smoke testing toca una vez cada función principal y lleva unos minutos. Las pruebas de regresión ejecutan cada flujo importante con sus resultados comprobados, y pueden llevar horas. Un smoke test dice que la compilación está viva, y una prueba de regresión dice que no se ha roto nada de lo que funcionaba.
¿El sanity testing forma parte de las pruebas de regresión?
En la práctica, sí. Un sanity check es una pequeña porción de la suite de regresión: las pruebas que cubren la zona que cambió. Se ejecuta justo después de la corrección, y la suite de regresión completa se ejecuta más tarde, por la noche o antes de una versión.
¿Qué va primero: smoke testing, sanity testing o pruebas de regresión?
El smoke testing va primero, en cada compilación nueva. El sanity testing va después, cuando la compilación trae una corrección o un cambio pequeño. Las pruebas de regresión van al final, por la noche o antes de una versión, porque son las más largas de las tres.
¿Qué es una prueba de verificación de compilación (build verification test)?
Una prueba de verificación de compilación es otro nombre para un smoke test. Se ejecuta justo después de crear una compilación y responde a una sola pregunta: si esa compilación es lo bastante estable como para seguir probándola.
¿Cuántas pruebas debe tener una suite de humo?
Pocas: una prueba corta por función principal, normalmente de cinco a diez en total, para que toda la suite se ejecute en unos minutos. Una suite de humo que se vuelve lenta deja de ejecutarse en cada compilación, y entonces no protege nada.
¿Un smoke test fallido debe hacer fallar la compilación?
Sí. Una compilación que no supera su smoke test no merece más pruebas, así que el pipeline debe detenerse y hay que avisar al equipo. Con GUI Test Studio, gtr-cli termina con un código de salida que el pipeline lee, así que una prueba fallida hace fallar la compilación.
¿Se pueden automatizar los smoke tests y las pruebas de regresión sin código?
Sí. Con GUI Test Studio usted graba cada flujo una vez, haciéndolo en su aplicación, y la prueba se reproduce sola. La suite de humo y la suite de regresión son entonces dos grupos de los mismos archivos de prueba, que gtr-cli ejecuta en cada compilación y cada noche.
Selenium, Playwright y Windows son marcas de sus respectivos propietarios.
Sigue leyendo
Todos los artículos
Automatización de pruebas
¿Qué son las pruebas de extremo a extremo? Una guía sencilla con un ejemplo real
10 min de lectura

Automatización de pruebas
¿Qué son las pruebas funcionales? Ejemplos, tipos y en qué se diferencian de las pruebas de extremo a extremo
9 min de lectura

Automatización de pruebas
Pruebas manuales frente a pruebas automatizadas: por qué las pruebas manuales se quedan cortas en las pruebas de extremo a extremo
15 min de lectura