¿Qué es el smoke testing en desarrollo de software? Es el primer vistazo rápido a un build recién generado: un puñado de comprobaciones que responden a una sola pregunta, «¿este build es lo bastante estable como para que merezca la pena probarlo?». Si la aplicación no arranca, la página de inicio de sesión lanza un error o el checkout nunca se completa, no tiene sentido ejecutar una batería de regresión de dos horas. La prueba de humo lo detecta en minutos y devuelve el build directamente a los desarrolladores.
Las pruebas de humo son una parte pequeña pero estructural de cualquier configuración seria de servicios de pruebas de software. Se sitúan entre las pruebas unitarias, que son responsabilidad de los desarrolladores, y las baterías más lentas de pruebas funcionales, de regresión y end-to-end, y actúan como el filtro que decide si esas baterías se ejecutan. Los equipos que se saltan este filtro suelen descubrir los builds rotos por la vía cara, cuando los testers o los clientes ya han perdido tiempo con ellos.
Esta guía aborda la definición, el origen del término, en qué se diferencia una prueba de humo de una prueba de verificación de build, del sanity testing y de las pruebas de regresión, cuándo ejecutarla, un proceso paso a paso, un checklist de prueba de humo de ejemplo, la configuración en CI/CD con un ejemplo de pipeline, herramientas para 2026, ventajas y limitaciones, y las buenas prácticas que mantienen una batería de humo rápida y fiable.
¿Qué es el smoke testing en desarrollo de software?
El smoke testing es una comprobación superficial y amplia de un nuevo build de software que verifica que sus funciones más importantes funcionan, para que el equipo pueda decidir si acepta el build para seguir probándolo o lo rechaza. No intenta encontrar todos los errores. Intenta encontrar los errores que convierten cualquier otra prueba en inútil.
El Glosario ISTQB, el vocabulario de referencia que usan los testers de software de todo el mundo, define una prueba de humo como «una batería de pruebas que cubre la funcionalidad principal de un componente o sistema para determinar si funciona correctamente antes de que comiencen las pruebas planificadas». En la práctica, tres ideas de esa definición son importantes:
- Solo la funcionalidad principal. Una prueba de humo cubre los flujos críticos, como arrancar la aplicación, iniciar sesión, cargar la pantalla principal y completar la transacción central. Los casos límite quedan para más adelante.
- Amplitud antes que profundidad. Toca de forma ligera muchas áreas del sistema en lugar de explorar a fondo una sola.
- Antes de las pruebas planificadas. Se ejecuta primero, como criterio de entrada. Una prueba de humo fallida detiene el pipeline; una superada abre la puerta a las pruebas funcionales, de regresión y de rendimiento.
El resultado de una prueba de humo es binario: el build «pasa el smoke» y sigue adelante, o «falla el smoke» y vuelve a desarrollo. Ese resultado tan simple es lo que hace que las pruebas de humo sean tan fáciles de automatizar y tan útiles como filtro.
¿Qué es una prueba de humo en desarrollo de software, en pocas palabras?
En pocas palabras, una prueba de humo en desarrollo de software es un chequeo rápido del estado de un nuevo build. Piense en un mecánico que gira la llave y comprueba que el motor arranca, que las luces se encienden y que los frenos responden antes de programar una revisión completa del coche. Nadie hace una revisión completa a un coche que no arranca, y nadie debería ejecutar un ciclo de pruebas completo sobre un build que tampoco arranca.
¿De dónde viene el término «smoke test»?
El término procede del hardware y la fontanería, mucho antes que del software. Los ingenieros electrónicos encendían por primera vez una placa de circuito recién montada y observaban si salía humo: si no había humo, la placa era al menos lo bastante segura como para probarla en serio. Los fontaneros bombeaban humo inofensivo por una instalación de tuberías nueva para ver por dónde se escapaba.
El software tomó prestada la idea en la década de 1990. El artículo de Steve McConnell «Daily Build and Smoke Test», publicado en IEEE Software en julio de 1996, la describía como «una práctica habitual en Microsoft y en algunas otras empresas de software empaquetado». En ese proceso, todo el producto se compilaba cada día y después se sometía a una comprobación relativamente sencilla para ver si «echaba humo» al ejecutarse. McConnell puso como ejemplo el proyecto Windows NT 3.0: unos 5.6 millones de líneas de código en 40,000 archivos fuente, donde un build completo podía tardar hasta 19 horas, y aun así un equipo de build de cuatro personas ejecutaba a diario el build y la prueba de humo.
El principio no ha cambiado desde entonces. Lo que ha cambiado es la velocidad: un pipeline de 2026 genera y somete a la prueba de humo una aplicación web en minutos, en cada merge, en lugar de una vez por noche.
Smoke testing frente a pruebas de verificación de build: ¿son lo mismo?
Sí, en la mayoría de los equipos el smoke testing y la prueba de verificación de build (BVT) significan lo mismo: un conjunto de comprobaciones que decide si un nuevo build es lo bastante bueno para probarlo. El único matiz está en el énfasis. «BVT» subraya que la comprobación está automatizada y se ejecuta en cada build; «smoke test» es el término cotidiano, más amplio.
El Glosario ISTQB define una prueba de verificación de build como «una prueba automatizada que valida la integridad de cada nuevo build y verifica su funcionalidad clave/principal, su estabilidad y su capacidad de ser probado». Si la compara con la definición de prueba de humo anterior, la coincidencia es evidente. Otros nombres que puede encontrar para la misma idea son prueba de admisión (intake test), prueba de confianza (confidence test) y prueba de aceptación de build (build acceptance test).
Por qué a veces se llama prueba de humo al sanity testing
La terminología varía según la fuente, y eso confunde a muchos equipos. El Glosario ISTQB recoge sanity test, intake test y confidence test como sinónimos de smoke test. Sin embargo, la mayoría de los profesionales y de los proveedores de herramientas usan «sanity test» para algo más acotado: una comprobación rápida de una corrección o funcionalidad concreta tras un cambio menor. Esta guía sigue el uso de los profesionales y compara ambos en detalle más abajo. Elija su equipo los términos que elija, acuérdelos en su estrategia de pruebas para que «ha fallado el smoke» signifique lo mismo para todos.
¿Por qué es importante el smoke testing?
El smoke testing es importante porque detiene los builds rotos en el momento más barato posible, antes de que los testers, los entornos de staging y los clientes pierdan tiempo con ellos. Una comprobación de cinco minutos que rechaza un build defectuoso puede ahorrar a un equipo de QA un día entero de investigación y a un equipo de lanzamiento un rollback de emergencia.
El coste de los defectos detectados tarde está bien documentado. El Planning Report 02-3 (2002) del NIST estimó que una infraestructura de pruebas de software insuficiente costaba a la economía de EE. UU. unos 59.5 mil millones de dólares al año, de los cuales aproximadamente 22.2 mil millones podían evitarse con pruebas más tempranas y mejores. Las pruebas de humo no sustituyen a unas pruebas exhaustivas, pero son una de las formas más baratas de adelantar la detección de defectos.
En el trabajo diario, una batería de humo fiable aporta al equipo:
- Una señal clara de «sí» o «no». Nadie discute si un build se puede probar; decide el filtro.
- Tiempo de QA protegido. Los testers empiezan cada ciclo con un build que se sabe que arranca y completa su flujo principal.
- Feedback más rápido para los desarrolladores. Un merge roto se notifica en minutos, mientras el cambio aún está fresco.
- Despliegues más seguros. Las pruebas de humo posteriores al despliegue detectan errores de configuración y de entorno que nunca aparecen en las pruebas unitarias.
- Una referencia de calidad visible. La tasa de superación del smoke a lo largo del tiempo muestra si la rama principal es cada vez más o menos estable.
También es una aplicación directa del enfoque shift-left: ejecutar las comprobaciones más importantes lo antes y lo más a menudo posible.
¿Cuándo conviene ejecutar pruebas de humo?
Ejecute una prueba de humo cada vez que el software cambie de una forma que pueda romper su funcionamiento básico: en cada nuevo build, antes de cualquier ciclo de pruebas planificado y justo después de cada despliegue. En un pipeline de CI/CD eso suele significar varias veces al día. Los desencadenantes habituales son:
- Se genera un nuevo build, ya sea por un merge a la rama principal o por un build nocturno.
- Antes de que empiecen las pruebas funcionales o de regresión, como criterio de entrada del ciclo de QA.
- Tras el despliegue en un entorno de pruebas o de staging, para confirmar que el entorno, la configuración y los datos están bien conectados.
- Inmediatamente después de un lanzamiento a producción, como comprobación posterior al despliegue de los flujos críticos en vivo.
- Tras cambios de infraestructura, como una actualización de la base de datos, una nueva región en la nube, la rotación de un certificado o la actualización de una dependencia.
- Tras un hotfix, para confirmar que la corrección no ha roto el arranque ni el flujo principal.
El paso de staging merece especial atención: un build puede superar todas las pruebas en la máquina de un desarrollador y aun así fallar en un entorno con otros secretos, feature flags o datos. Nuestra guía sobre el staging en desarrollo de software explica cómo mantener ese entorno lo bastante cerca de producción para que los resultados del smoke tengan sentido.
¿Quién realiza el smoke testing?
El smoke testing suele ser responsabilidad de los ingenieros de QA o de automatización de pruebas que diseñan la batería, pero en los equipos modernos se ejecuta automáticamente y todo el equipo actúa según el resultado. Quién lo ejecuta en realidad depende de la madurez del equipo:
- Ingenieros de QA: eligen los flujos críticos, escriben los casos de prueba de humo y mantienen la batería en buen estado.
- Desarrolladores: ejecutan la batería en local antes de hacer push y corrigen de inmediato un smoke fallido, porque bloquea a todos.
- Ingenieros de DevOps o de plataforma: integran la batería en el pipeline de CI/CD y en las comprobaciones posteriores al despliegue.
- Release managers: tratan un smoke superado como condición obligatoria para promover un build.
En equipos pequeños sin testers dedicados, los desarrolladores asumen todo el proceso. Funciona, siempre que alguien sea responsable de forma explícita de mantener la batería corta y fiable.
Cómo realizar una prueba de humo: 6 pasos
Para realizar una prueba de humo, identifique las pocas funciones sin las que el producto no puede vivir, conviértalas en casos de prueba breves y repetibles, ejecútelos en cada nuevo build en un entorno similar a producción y acepte o rechace el build según un único resultado de superado o fallido. Los pasos siguientes sirven para productos web, móviles y de API.
- Identifique los flujos críticos. Enumere los flujos que dejarían el producto inutilizable si fallaran: el arranque, el inicio de sesión, la pantalla principal, la transacción central (checkout, reserva, pago, subida de archivos) y cualquier integración de la que dependa el negocio.
- Escriba casos de prueba breves e independientes. Una prueba por cada comprobación crítica, y que cada una pueda ejecutarse por sí sola con datos de prueba conocidos. Limite el número de pasos y defina resultados esperados sin ambigüedad.
- Prepare el entorno y los datos. Utilice un entorno estable y similar a producción, con cuentas precargadas y métodos de pago de prueba. Las pruebas de humo que dependen de datos compartidos y cambiantes se vuelven inestables (flaky) muy rápido.
- Ejecute la suite sobre el nuevo build. Láncela automáticamente desde el pipeline o recorra la checklist a mano en productos en fase muy temprana.
- Tome una decisión go/no-go. Cualquier fallo rechaza el build. No acepte «aprobado con excepciones»: si una comprobación no es crítica, no tiene cabida en la suite de smoke tests.
- Informe y corrija. Envíe el fallo, los logs y las capturas de pantalla a los desarrolladores que hicieron el cambio, corrija el build y vuelva a pasar la prueba de humo antes de cualquier otra prueba.
¿Qué incluye una suite de smoke tests? Checklist de ejemplo
Una buena suite de smoke tests contiene solo las comprobaciones cuyo fallo haría inútil seguir probando: normalmente entre 5 y 30 casos de prueba que se ejecutan en pocos minutos. La lista exacta depende del producto, pero la mayoría de las suites cubren el arranque, la autenticación, la navegación, la transacción principal y las integraciones clave.
Ejemplo de prueba de humo: una aplicación web de e-commerce
La siguiente tabla muestra una checklist realista de pruebas de humo para una tienda online. Cada línea es una única comprobación con una condición de aprobado clara.
| # | Comprobar | Condición de aprobado |
|---|---|---|
| 1 | La página de inicio carga | HTTP 200, navegación principal y cuadrícula de productos visibles |
| 2 | El usuario puede iniciar sesión | La cuenta de prueba inicia sesión y ve su nombre de cuenta |
| 3 | La búsqueda devuelve resultados | Un producto conocido aparece para una consulta conocida |
| 4 | La página de producto se abre | Se muestran el precio, las imágenes y el botón «Añadir al carrito» |
| 5 | El carrito funciona | El artículo se añade y el total del carrito se actualiza |
| 6 | El proceso de compra se completa | El pago con tarjeta de prueba se realiza en el sandbox y se muestra el número de pedido |
| 7 | Se envía la confirmación del pedido | El evento o el correo de confirmación llega a la bandeja de prueba |
| 8 | El endpoint de salud está en verde | La API, la base de datos y el proveedor de pagos informan de un estado correcto |
Fíjese en lo que falta: casos límite de descuentos, reglas de validación de direcciones, todos los métodos de pago, compatibilidad entre navegadores. Todo eso corresponde a las suites funcionales y de regresión. La prueba de humo solo demuestra que la tienda puede recibir un pedido.
Ejemplos de pruebas de humo para apps móviles y API
En una app móvil, una suite de smoke tests suele comprobar que la app se instala y se abre sin bloquearse, que aparece la pantalla de onboarding o de inicio de sesión, que el usuario puede iniciar sesión, que la pantalla principal carga datos del backend y que el registro de notificaciones push se completa. En una API, comprueba que el servicio arranca, que el endpoint de salud responde, que la autenticación devuelve un token y que una llamada de lectura y otra de escritura sobre el recurso principal funcionan con los códigos de estado y la estructura de respuesta esperados.
Tipos de pruebas de humo: manuales, automatizadas e híbridas
Las pruebas de humo pueden ser manuales, automatizadas o una combinación de ambas. Las automatizadas son la opción habitual en cualquier producto con un pipeline de CI/CD, mientras que las comprobaciones manuales siguen teniendo sentido en productos muy tempranos y en revisiones visuales o específicas de dispositivo difíciles de automatizar.
| Tipo | Cómo funciona | Ideal para | Principal inconveniente |
|---|---|---|---|
| Manual | Un tester sigue una breve checklist escrita en cada build | Prototipos, MVP, lanzamientos poco frecuentes | Lenta, irregular, no escala a muchos builds al día |
| Automatizada | Unos scripts ejecutan las comprobaciones desde el pipeline de CI/CD en cada build | Productos con merges y despliegues frecuentes | Requiere un esfuerzo inicial y mantenimiento continuo |
| Híbrido | Comprobaciones básicas automatizadas más algunas revisiones manuales de aspecto visual o dispositivos | Apps móviles, productos con mucha interfaz | La parte manual puede saltarse discretamente cuando aprietan los plazos |
Pruebas de humo en distintos niveles de prueba
Las pruebas de humo no se limitan al sistema completo. Los equipos suelen ejecutar una comprobación de humo en varios niveles: una de integración confirma que los servicios arrancan y pueden comunicarse entre sí, una de sistema confirma que los flujos críticos de extremo a extremo funcionan en un entorno desplegado y una de aceptación confirma que una release candidate está lista para los usuarios de negocio. Las pruebas unitarias ya se ejecutan con cada cambio, por lo que rara vez se les llama pruebas de humo, aunque una etapa unitaria fallida bloquea el pipeline del mismo modo. Para ver cómo encajan las pruebas unitarias, consulte nuestra guía sobre las pruebas unitarias en el desarrollo de software.
Pruebas de humo frente a pruebas de cordura y pruebas de regresión
Las pruebas de humo comprueban que un nuevo build es lo bastante estable como para poder probarlo, las pruebas de cordura (sanity testing) comprueban que una corrección concreta o un cambio pequeño funciona según lo previsto, y las pruebas de regresión comprueban que las funciones existentes siguen funcionando tras cualquier cambio. Su profundidad aumenta en ese orden: la de humo es la más amplia y superficial; la de regresión, la más profunda y lenta.
| Aspecto | Pruebas de humo | Pruebas de cordura | Pruebas de regresión |
|---|---|---|---|
| Pregunta que responde | ¿Se puede probar este build? | ¿Funciona esta corrección o este cambio? | ¿Se ha roto algo más? |
| Alcance | Amplia y superficial, todos los caminos críticos | Acotada y centrada en el área modificada | Amplia y profunda, todo el producto |
| Cuándo | En cada nuevo build y despliegue | Tras corregir un bug o hacer un cambio menor | Antes de los lanzamientos y tras cambios importantes |
| Duración típica | Minutos | De minutos a una hora | Horas, a veces días si es manual |
| ¿Con guion? | Sí, una suite fija y estable | A menudo sin guion o ad hoc | Sí, una suite grande y mantenida |
| ¿Suele automatizarse? | Casi siempre | A veces | Mayoritariamente, con algunas comprobaciones manuales |
| Resultado si falla | Build rechazado, sin más pruebas | La corrección vuelve al desarrollador | Lanzamiento bloqueado hasta corregir los defectos |
Una forma sencilla de recordar la diferencia: la prueba de humo pregunta «¿funciona?», la de cordura pregunta «¿tiene sentido lo que acabamos de cambiar?» y la de regresión pregunta «¿sigue funcionando todo lo que funcionaba antes?». Para ver el mapa completo de tipos de pruebas y cómo los combinan los equipos de QA, consulte nuestra guía sobre el aseguramiento de la calidad en el desarrollo de software.
¿Cómo funcionan las pruebas de humo en un pipeline de CI/CD?
En un pipeline de CI/CD, la suite de smoke tests se ejecuta automáticamente justo después de las etapas de build y pruebas unitarias, y de nuevo justo después de cada despliegue; si falla, el pipeline se detiene y el build no se promociona. Así, las pruebas de humo dejan de ser un hábito manual y se convierten en un control de calidad obligatorio.
Una secuencia típica es la siguiente: build, pruebas unitarias, despliegue en un entorno de pruebas, pruebas de humo, después las suites funcionales y de regresión más largas, luego el despliegue en producción y, por último, una prueba de humo posterior al despliegue contra producción. Las dos etapas de humo detectan problemas distintos. La previa al lanzamiento detecta código roto; la posterior al despliegue detecta errores de configuración, secretos, migraciones e infraestructura.
Este es un job simplificado de GitHub Actions que ejecuta una suite de smoke tests de Playwright contra un entorno de staging recién desplegado y hace fallar el pipeline si falla cualquier prueba de humo:
smoke-test:
needs: deploy-staging
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/checkout@v4
- run: npm ci
- run: npx playwright install --with-deps chromium
- name: Run smoke suite against staging
run: npx playwright test --grep @smoke
env:
BASE_URL: https://staging.example.com
Dos detalles hacen que esto funcione en la práctica. La etiqueta @smoke permite al equipo mantener las pruebas de humo dentro del proyecto de pruebas principal pero ejecutar solo el subconjunto etiquetado, y el límite timeout-minutes evita que un entorno colgado bloquee el pipeline durante una hora. La misma idea se aplica en GitLab CI, Jenkins, Azure DevOps o cualquier otro runner. Para el diseño completo del pipeline, consulte nuestra guía sobre CI/CD en el desarrollo de software.
¿Cuánto debe durar una suite de smoke tests?
Una suite de smoke tests debería terminar, por lo general, en menos de 5 a 10 minutos, y muchos equipos aspiran a bajar de 5. Si tarda más, deja de ofrecer feedback rápido y los desarrolladores empiezan a ignorarla o a saltársela. Cuando una suite supera ese límite, pase las comprobaciones más lentas o menos críticas a la suite de regresión en lugar de aceptar un control más lento.
Herramientas de pruebas de humo en 2026
La mayoría de los equipos crean sus pruebas de humo con las mismas herramientas de automatización que ya usan para las pruebas funcionales y etiquetan un pequeño subconjunto como suite de smoke tests. La herramienta adecuada depende de lo que se pruebe: una interfaz web, una app móvil o una API.
| Capa | Herramientas habituales | Comprobaciones de humo típicas |
|---|---|---|
| Interfaz web | Playwright, Cypress, Selenium WebDriver | Carga de páginas, inicio de sesión, flujo de usuario principal |
| Móvil | Appium, Espresso (Android), XCUITest (iOS), Maestro | Instalación, arranque sin bloqueos, inicio de sesión, datos de la pantalla principal |
| API | Postman con Newman, REST Assured, pytest con requests, k6 | Endpoint de estado (health), token de autenticación, una llamada de lectura y otra de escritura |
| Ejecutores de pruebas | JUnit, TestNG, pytest, Jest, Vitest | Agrupar y etiquetar el subconjunto de smoke tests |
| CI/CD | GitHub Actions, GitLab CI, Jenkins, Azure DevOps | Ejecutar la suite como puerta de control tras el build y el despliegue |
| Comprobaciones en producción | Monitorización sintética en su plataforma de observabilidad | Comprobaciones programadas, al estilo smoke, de los flujos críticos en vivo |
La herramienta importa menos que la disciplina. Una suite de Playwright con diez pruebas que se ejecuta en cada merge vale más que un framework sofisticado que nadie mantiene.
Ventajas y limitaciones de las pruebas de humo
La principal ventaja de las pruebas de humo es que detectan en cuestión de minutos y a un coste muy bajo los defectos que rompen el build; su principal limitación es que apenas dicen nada sobre la calidad de lo que queda fuera de los flujos críticos. Superar una prueba de humo significa «merece la pena probarlo», no «listo para el lanzamiento».
| Ventajas | Limitaciones |
|---|---|
| Detecta fallos críticos a los pocos minutos de cada build | Superficial por diseño: se le escapan la mayoría de los defectos funcionales |
| Ahorra tiempo de QA al rechazar builds que no se pueden probar | Puede generar una falsa sensación de seguridad si se usa como control de lanzamiento |
| Fácil de automatizar y de ejecutar en cada cambio | Requiere mantenimiento a medida que cambian los flujos críticos |
| Detecta errores de entorno y de configuración tras el despliegue | Las pruebas inestables (flaky) minan rápidamente la confianza en la puerta de control |
| Ofrece una señal sencilla y compartida de seguir o no seguir | Se vuelve lenta si los equipos siguen añadiendo comprobaciones no críticas |
Buenas prácticas de las pruebas de humo
Las mejores suites de smoke tests son cortas, estables, automatizadas y se limitan estrictamente a los flujos críticos; la mayoría de los fracasos de las pruebas de humo se deben a suites que crecieron demasiado o se volvieron demasiado inestables como para fiarse de ellas. Estas siete prácticas mantienen la utilidad de una suite:
- Manténgala pequeña. Empiece con entre 5 y 15 comprobaciones y añada una nueva solo si su fallo haría inútil seguir probando.
- Fije un presupuesto de tiempo. Acuerde una duración máxima, por ejemplo 5 minutos, y trate cualquier exceso como un defecto.
- Haga que cada prueba sea independiente. Cada comprobación debe crear o restablecer sus propios datos y poder ejecutarse en cualquier orden.
- Corrija o elimine de inmediato las pruebas inestables. Una puerta de control que falla al azar enseña al equipo a relanzarla e ignorarla.
- Ejecútela en un entorno similar al de producción. Mismo estilo de configuración, mismas integraciones en modo sandbox y datos realistas.
- Haga una prueba de humo en producción tras cada lanzamiento. Utilice cuentas de solo lectura o cuentas de prueba dedicadas para que las comprobaciones en vivo nunca toquen datos reales de clientes.
- Revise la suite cada trimestre. Elimine las comprobaciones de funcionalidades retiradas y añada otras para los nuevos flujos críticos.
Métricas que conviene seguir en su suite de smoke tests
Siga unas pocas cifras sencillas para saber si la suite de smoke tests cumple su función: la tasa de éxito de las pruebas de humo en la rama principal, la duración mediana de la suite, la tasa de fallos inestables (fallos que pasan al relanzar) y el número de defectos detectados en fases posteriores que una prueba de humo debería haber detectado. Encajan de forma natural junto a métricas de entrega como la tasa de fallos en los cambios, que explica nuestra guía de KPI de desarrollo de software.
Errores habituales en las pruebas de humo
El error más habitual en las pruebas de humo es dejar que la suite se convierta en una minisuite de regresión que tarda demasiado y falla con demasiada frecuencia. Otros problemas frecuentes son fáciles de detectar una vez que se conocen:
- Probar casos límite en la suite de smoke tests en lugar de los flujos críticos principales.
- Ejecutar las pruebas de humo solo antes de los lanzamientos en lugar de en cada build, lo que retrasa el feedback varios días.
- Omitir la prueba de humo posterior al despliegue, de modo que los errores de configuración llegan antes a los usuarios.
- Compartir datos de prueba entre pruebas, lo que provoca fallos aleatorios cuando se ejecutan en paralelo.
- Permitir saltarse manualmente una prueba de humo fallida «solo por esta vez», lo que anula la puerta de control.
Si sus lanzamientos siguen rompiéndose el primer día pese a tener una suite de smoke tests, una evaluación de QA independiente puede revisar qué flujos críticos están cubiertos realmente, medir las tasas de inestabilidad y los tiempos de ejecución, y reconstruir la puerta de control para que el equipo vuelva a confiar en ella.
Preguntas frecuentes
¿Qué es el smoke testing en desarrollo de software?
Las pruebas de humo en el desarrollo de software son un conjunto rápido de comprobaciones que se ejecuta en cada nuevo build para confirmar que funcionan sus funciones más críticas, como el arranque, el inicio de sesión y la transacción principal. Deciden si el build es lo bastante estable para pruebas más profundas. Una prueba de humo fallida rechaza el build de inmediato, de modo que los testers no pierden tiempo con software que está roto en lo esencial.
¿Qué es una prueba de humo en el desarrollo de software? Un ejemplo
Una prueba de humo es una comprobación breve, automatizada o manual, de los flujos críticos de un build. En una tienda online, una prueba de humo podría confirmar que la página de inicio carga, que un usuario de prueba puede iniciar sesión, que se puede añadir un producto al carrito y que un pago en sandbox se completa con un número de pedido. Si cualquiera de estas comprobaciones falla, el build vuelve a los desarrolladores antes de que empiece cualquier otra prueba.
¿Qué diferencia hay entre las pruebas de humo y las pruebas de cordura (sanity testing)?
Las pruebas de humo son una comprobación amplia y superficial de que todo un build nuevo es lo bastante estable para probarlo. Las pruebas de cordura (sanity testing) son una comprobación acotada de que una corrección concreta o un cambio pequeño funciona como se espera. Las pruebas de humo se ejecutan en cada build y casi siempre están automatizadas, mientras que las de cordura se ejecutan tras cambios puntuales y a menudo se hacen a mano. Algunos glosarios, entre ellos el de ISTQB, tratan ambos términos como sinónimos.
¿Las pruebas de humo son lo mismo que las pruebas de regresión?
No. Las pruebas de humo comprueban en pocos minutos solo los flujos críticos de un build nuevo para decidir si se puede probar. Las pruebas de regresión vuelven a ejecutar una suite mucho mayor para confirmar que las funcionalidades existentes siguen funcionando tras un cambio, y pueden durar horas. Las pruebas de humo se ejecutan primero como puerta de control; las de regresión, más tarde, antes de un lanzamiento.
¿Cuántas pruebas debe tener una suite de smoke tests?
La mayoría de las suites de smoke tests contienen entre 5 y 30 pruebas, y el número adecuado es el conjunto más pequeño que cubra todos los flujos críticos del producto. Una regla útil es incluir una comprobación solo si su fallo haría inútil cualquier prueba posterior. Si la suite tarda más de unos 5 a 10 minutos, probablemente ha crecido demasiado.
¿Se pueden automatizar las pruebas de humo?
Sí, y en cualquier producto con un pipeline de CI/CD deberían estarlo. Las pruebas de humo automatizadas se ejecutan en cada build y en cada despliegue con herramientas como Playwright, Cypress, Appium o Postman con Newman, y bloquean el pipeline cuando falla una comprobación crítica. Las listas de comprobación manuales siguen teniendo sentido en prototipos tempranos y en revisiones visuales difíciles de automatizar.
¿Quién es responsable de las pruebas de humo?
Los ingenieros de QA o de automatización de pruebas suelen diseñar y mantener la suite de smoke tests, los ingenieros DevOps la integran en el pipeline de CI/CD y los desarrolladores corrigen cualquier build que no la supere. En equipos pequeños sin testers dedicados, los desarrolladores asumen todo el proceso. Sea quien sea el responsable, una persona debe rendir cuentas claramente de que la suite siga siendo rápida y fiable.
Fuentes
- ISTQB, Glossary of Terms used in Software Testing (en inglés), entradas «smoke test» y «build verification test» (v4.2, 2023)
- Steve McConnell, Daily Build and Smoke Test (en inglés), IEEE Software, vol. 13, n.º 4, julio de 1996, págs. 143–144
- NIST, Planning Report 02-3: The Economic Impacts of Inadequate Infrastructure for Software Testing (en inglés) (2002)
- Documentación de Playwright, Test annotations and tags (en inglés)