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.

Por Ait Nohaila, Representante de desarrollo de negocio 9 min de lectura

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?

Cada cuadrícula es la misma aplicación: sus funciones de izquierda a derecha, la profundidad de las pruebas de arriba abajo. Las celdas iluminadas son lo que mira cada tipo de prueba.

¿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é compararSmoke testingSanity testingPruebas de regresión
La pregunta que hace¿Merece la pena probar esta compilación?¿Funciona esta corrección?¿Se rompió algo más?
AmplitudToda la aplicaciónUna función o una correcciónToda la aplicación
ProfundidadSuperficial: un toque por funciónProfunda, en un solo lugarProfunda, allí donde importa
Cuándo se ejecutaEn cada compilaciónDespués de una corrección o un cambio pequeñoCada noche y antes de una versión
Cuánto tardaUnos minutosUnos minutosUna hora o más, sin nadie delante
Qué significa un falloLa compilación se rechazaLa corrección vuelve atrásUna 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.

Cuanto más corta es la prueba, más a menudo se ejecuta. La más larga se ejecuta cuando nadie la está esperando.

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

EjemploUna aplicación de facturación, tres días

Las cifras de abajo son una ilustración, con números redondos.

CuándoQué se ejecutóQué encontró
Lunes, llega una compilación nuevaLa 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 impuestoUn sanity check: la prueba de la factura ejecutada de nuevo, con su total comprobado.Se supera. La corrección funciona.
Martes por la nocheLa 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

Iniciar sesiónBuscar un productoPagoHistorial de pedidosReembolsoExportar facturas

En cada compilación

Sanity check

1 de 6 pruebas

Iniciar sesiónBuscar un productoPagoHistorial de pedidosReembolsoExportar facturas

Después de una corrección en el pago

Suite de regresión

6 de 6 pruebas

Iniciar sesiónBuscar un productoPagoHistorial de pedidosReembolsoExportar facturas

Cada noche

Seis pruebas grabadas, hechas una sola vez. Una suite de humo, un sanity check y una suite de regresión son tres maneras de elegir entre ellas.
Tipo de ejecuciónQué es, con pruebas grabadasCómo se ejecuta
Suite de humoUnas pocas pruebas cortas, una por función principal.Con gtr-cli, en cada compilación.
Sanity checkLa única prueba que cubre la corrección, ejecutada de nuevo.Con Ejecutar prueba, o desde la mitad de la prueba.
Suite de regresiónTodas 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. 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. 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. 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. 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. 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. 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.

Un sanity check es un clic en Ejecutar prueba, y la tarjeta Ejecuciones conserva el resultado junto a los anteriores.

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.

Las mismas pruebas, dos momentos
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ímiteLo que significa
Una ejecución usa la pantalla realLas 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 partidaUna 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ó comprobarUna 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.