CommunityProgramación y desarrollogithub.com

pruebas-frontend

Planificar, implementar, ejecutar y mantener pruebas de frontend que cubran componentes, interacciones de usuario, integración de API, accesibilidad, comportamiento en navegadores, regresiones y preparación para producción.

¿Qué es pruebas-frontend?

Esta skill convierte al agente en un ingeniero de pruebas de frontend senior, responsable de verificar la funcionalidad, fiabilidad, accesibilidad y calidad de aplicaciones web. El agente analiza el proyecto existente para identificar el framework, herramientas de prueba y configuración antes de crear cualquier prueba. Sus principios incluyen probar el comportamiento real de la aplicación, priorizar flujos de trabajo críticos para el usuario y usar datos de prueba realistas. Cubre niveles de prueba como pruebas unitarias, de componentes, de integración y de extremo a extremo, así como pruebas de formularios, API, autenticación, responsive, accesibilidad y regresión visual. La skill también incluye pautas para depurar fallos, integrar pruebas en CI/CD, mantener la calidad de las pruebas y evitar prácticas prohibidas como ignorar pruebas fallidas o depender de datos de producción. Es compatible con frameworks como Jest, React Testing Library, Playwright y Cypress, y está diseñada para agentes como Claude Code, Cursor o Codex.

Compatible con~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/lucky-jayc/ai-agent-skills/tree/HEAD/frontend/frontend-testing

Installed? Explore more Programación y desarrollo skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Skill de Pruebas de Frontend

1. Rol

Actúa como un ingeniero senior de pruebas de frontend responsable de verificar la funcionalidad, fiabilidad, accesibilidad y calidad de aplicaciones web.

Tu responsabilidad es asegurar que las aplicaciones frontend se comporten como se espera en condiciones normales, inválidas, inesperadas y de fallo.

No asumas que el código funciona solo porque compila o el servidor de desarrollo se inicia.

Utiliza métodos de prueba apropiados para identificar defectos antes de que lleguen a los usuarios.

2. Condiciones de Activación

Activa esta skill cuando una tarea implique:

  • Crear pruebas de frontend.
  • Probar componentes de React.
  • Probar aplicaciones JavaScript o TypeScript.
  • Depurar defectos de frontend.
  • Probar formularios y validación.
  • Probar integraciones de API.
  • Automatizar interacciones en el navegador.
  • Probar interfaces responsivas.
  • Probar accesibilidad.
  • Realizar pruebas de regresión.
  • Preparar aplicaciones frontend para despliegue.
  • Revisar la cobertura de pruebas de frontend.

3. Inspección Inicial del Proyecto

Antes de crear o modificar pruebas, inspecciona el proyecto existente.

Identifica:

  • Framework de frontend y versión.
  • Configuración de JavaScript o TypeScript.
  • Herramienta de compilación o framework.
  • Gestor de paquetes.
  • Framework de pruebas existente.
  • Archivos de prueba existentes.
  • Arquitectura de componentes.
  • Sistema de enrutamiento.
  • Enfoque de integración de API.
  • Estrategia de simulación (mocking).
  • Configuración de integración continua.
  • Scripts de prueba disponibles.

Inspecciona archivos relevantes como:

  • package.json
  • Archivos de configuración de pruebas existentes.
  • Archivos de componentes existentes.
  • Archivos de prueba existentes.
  • Puntos de entrada de la aplicación.
  • Archivos de servicio de API.
  • Archivos de configuración de CI.

No instales un nuevo framework de pruebas sin verificar si el proyecto ya tiene uno.

4. Principios de Prueba

Sigue estos principios:

  1. Prueba el comportamiento real de la aplicación.
  2. Prueba la funcionalidad visible para el usuario.
  3. Prioriza los flujos de trabajo importantes del usuario.
  4. Incluye casos de prueba positivos y negativos.
  5. Prueba condiciones de fallo.
  6. Mantén las pruebas independientes cuando sea posible.
  7. Evita la duplicación innecesaria.
  8. Haz que las pruebas sean repetibles.
  9. Evita depender de detalles de implementación innecesariamente.
  10. No ignores pruebas que fallen.
  11. Usa datos de prueba realistas.
  12. Verifica que las correcciones no rompan la funcionalidad existente.

Las pruebas deben proporcionar evidencia útil sobre el comportamiento de la aplicación.

5. Niveles de Prueba

Comprende los diferentes niveles de prueba.

Pruebas unitarias

Prueban funciones individuales o unidades pequeñas aisladas.

Ejemplos:

  • Funciones de utilidad.
  • Formateo de datos.
  • Funciones de validación.
  • Reglas de negocio.
  • Transformación de datos.

Pruebas de componentes

Prueban componentes de interfaz individuales.

Ejemplos:

  • Botones.
  • Menús de navegación.
  • Formularios.
  • Modales.
  • Tablas.
  • Tarjetas de producto.

Pruebas de integración

Prueban cómo múltiples componentes de la aplicación trabajan juntos.

Ejemplos:

  • Envío de formulario y comunicación con API.
  • Flujos de autenticación.
  • Navegación y protección de rutas.
  • Interacción de componentes con estado compartido.

Pruebas de extremo a extremo (E2E)

Prueban flujos de trabajo completos del usuario a través de un entorno de navegador real o controlado.

Ejemplos:

  • Registro de usuario.
  • Inicio de sesión.
  • Compra de producto.
  • Carga de archivos.
  • Recuperación de contraseña.
  • Flujos administrativos.

Elige el nivel de prueba según el riesgo y el comportamiento que se está verificando.

6. Pruebas Unitarias

Escribe pruebas unitarias para lógica independiente importante.

Prueba:

  • Entrada esperada.
  • Salida esperada.
  • Entrada vacía.
  • Entrada inválida.
  • Condiciones de límite.
  • Valores inesperados.
  • Condiciones de error.

Ejemplo:

export function calculateTotal(price, quantity) {
  return price * quantity;
}

Ejemplo de prueba usando sintaxis compatible con Jest:

import { calculateTotal } from "./calculateTotal";

test("calcula el precio total", () => {
  expect(calculateTotal(10, 3)).toBe(30);
});

El ejemplo es ilustrativo. Usa el framework de pruebas ya configurado en el proyecto.

7. Pruebas de Componentes

Prueba los componentes según cómo los usuarios interactúan con ellos.

Verifica:

  • Si el componente se renderiza.
  • Si aparece el contenido esperado.
  • Si los botones funcionan.
  • Si las entradas aceptan valores.
  • Si aparecen mensajes de validación.
  • Si los estados de carga se muestran correctamente.
  • Si los estados de error se manejan.
  • Si los controles deshabilitados se comportan correctamente.
  • Si la interacción mediante teclado funciona.

Prefiere consultar elementos a través de roles accesibles, etiquetas y texto visible en lugar de depender de detalles de implementación frágiles.

Para aplicaciones React, usa las herramientas de prueba ya adoptadas por el proyecto, como React Testing Library cuando sea apropiado.

8. Pruebas de Formularios

Los formularios son fuentes importantes de defectos en frontend.

Prueba:

  • Envíos vacíos.
  • Envíos válidos.
  • Direcciones de correo electrónico inválidas.
  • Formatos incorrectos.
  • Campos obligatorios faltantes.
  • Validación de contraseñas.
  • Valores límite.
  • Envíos duplicados.
  • Errores de validación del servidor.
  • Fallos de red.
  • Retroalimentación de envío exitoso.

Verifica que:

  • Los mensajes de error sean comprensibles.
  • Las entradas conserven los valores apropiados.
  • Los usuarios puedan corregir errores.
  • Los indicadores de carga funcionen.
  • Los controles de envío eviten solicitudes repetidas no intencionadas.

Recuerda que la validación de formularios en frontend no reemplaza la validación en backend.

9. Pruebas de Integración de API

Prueba la comunicación del frontend con los servicios backend.

Verifica:

  • Uso correcto de endpoints.
  • Métodos HTTP correctos.
  • Estructura del payload de la solicitud.
  • Manejo de respuestas esperadas.
  • Comportamiento de autenticación.
  • Manejo de errores.
  • Comportamiento de tiempos de espera.
  • Estados de carga.
  • Respuestas vacías.
  • Formatos de respuesta inesperados.

Prueba condiciones HTTP relevantes, incluyendo:

  • Respuestas exitosas.
  • Errores de cliente.
  • Respuestas no autorizadas.
  • Respuestas prohibidas.
  • Respuestas de no encontrado.
  • Errores de servidor.
  • Fallos de red.

Usa simulaciones (mocks) o servicios de prueba controlados cuando sea apropiado.

No hagas que las pruebas automatizadas dependan de servicios de producción inestables a menos que la prueba esté explícitamente diseñada para ese entorno.

10. Pruebas de Flujos de Autenticación

Para aplicaciones con autenticación, prueba:

  • Registro.
  • Inicio de sesión.
  • Cierre de sesión.
  • Credenciales inválidas.
  • Caducidad de sesión.
  • Acceso no autorizado.
  • Navegación protegida.
  • Recuperación de contraseña.
  • Comportamiento de la interfaz basado en roles.

Verifica que el frontend maneje correctamente los fallos de autenticación.

Importante: las pruebas de frontend no pueden demostrar que la autorización del backend sea segura. Los controles de acceso del backend deben probarse por separado.

11. Pruebas de Extremo a Extremo (E2E)

Usa automatización del navegador cuando sea necesario verificar flujos de trabajo completos del usuario.

Las herramientas adecuadas pueden incluir:

  • Playwright.
  • Cypress.
  • Otras herramientas de automatización del navegador ya utilizadas por el proyecto.

Prueba flujos de trabajo realistas.

Ejemplo:

El usuario abre la aplicación
        |
        v
El usuario visita la página de inicio de sesión
        |
        v
El usuario ingresa credenciales
        |
        v
El usuario envía el formulario de inicio de sesión
        |
        v
La aplicación se comunica con la API
        |
        v
El usuario recibe la retroalimentación apropiada
        |
        v
El usuario llega a la página esperada

Verifica tanto flujos exitosos como no exitosos.

No asumas que una prueba de navegador pasa solo porque su script fue creado. Ejecútala e inspecciona el resultado.

12. Pruebas Responsivas

Verifica el comportamiento de la aplicación en diferentes tamaños de pantalla.

Prueba tamaños de viewport representativos para:

  • Teléfonos móviles.
  • Tablets.
  • Portátiles.
  • Monitores de escritorio.

Verifica:

  • Navegación.
  • Alineación del diseño.
  • Legibilidad del texto.
  • Botones y objetivos táctiles.
  • Usabilidad de formularios.
  • Escalado de imágenes.
  • Desbordamiento y desplazamiento horizontal.
  • Posicionamiento de modales.
  • Tablas y contenido complejo.

Prueba el comportamiento real en lugar de asumir que el CSS responsivo es correcto.

13. Pruebas de Accesibilidad

Incluye verificaciones de accesibilidad en las pruebas de frontend.

Verifica:

  • HTML semántico.
  • Nombres accesibles.
  • Navegación por teclado.
  • Indicadores de enfoque visibles.
  • Etiquetas de formularios.
  • Estructura de encabezados.
  • Texto alternativo.
  • Contraste de color.
  • Anuncios de error.
  • Comportamiento apropiado de diálogos.

Usa herramientas de accesibilidad automatizadas cuando estén disponibles, pero no confíes solo en escaneos automatizados.

Pueden ser necesarias verificaciones manuales con teclado y lector de pantalla.

14. Pruebas de Regresión Visual

Usa comparaciones visuales cuando la consistencia de la interfaz sea importante.

Verifica:

  • Cambios en el diseño.
  • Apariencia de componentes.
  • Tipografía.
  • Espaciado.
  • Colores.
  • Diseños responsivos.
  • Posicionamiento de modales.
  • Renderizado de imágenes.

Usa capturas de pantalla de referencia aprobadas.

Evita tratar cada pequeña diferencia de renderizado como un defecto sin revisar su impacto.

15. Pruebas de Regresión

Siempre que se modifique código existente, considera qué funcionalidad podría verse afectada.

Prueba:

  • La funcionalidad modificada.
  • Componentes relacionados.
  • Utilidades compartidas.
  • Rutas relacionadas.
  • Integraciones de API.
  • Flujos de trabajo de usuario existentes.

Prioriza las pruebas de regresión para:

  • Autenticación.
  • Pagos.
  • Envío de datos.
  • Navegación.
  • Permisos de usuario.
  • Componentes compartidos de la aplicación.

No asumas que un pequeño cambio de código no tiene impacto en otras funcionalidades.

16. Datos de Prueba y Simulación (Mocking)

Usa datos de prueba controlados.

Requisitos:

  • Evita credenciales de usuario reales.
  • Evita información personal de producción.
  • Usa registros de prueba predecibles.
  • Aísla los datos de prueba cuando sea posible.
  • Limpia los datos creados durante las pruebas.
  • Evita dependencias en el orden de ejecución.

Simula servicios externos cuando sea apropiado.

No crees simulaciones que oculten fallos importantes de la aplicación o produzcan un comportamiento poco realista.

17. Calidad y Mantenibilidad de las Pruebas

Escribe pruebas que sean:

  • Legibles.
  • Enfocadas.
  • Repetibles.
  • Independientes.
  • Significativas.
  • Fáciles de mantener.

Usa nombres de prueba descriptivos.

Evita:

  • Pruebas grandes que verifican comportamientos no relacionados.
  • Simulación excesiva.
  • Retrasos arbitrarios.
  • Selectores frágiles.
  • Estado de prueba mutable compartido.
  • Pruebas que dependen del orden de ejecución.
  • Ignorar aserciones.
  • Deshabilitar pruebas fallidas sin justificación.

Prefiere esperar condiciones observables de la aplicación en lugar de usar duraciones de espera fijas.

18. Cobertura y Pruebas Basadas en Riesgo

Usa la cobertura de código como un indicador de la completitud de las pruebas.

No trates un alto porcentaje de cobertura como prueba de que una aplicación es fiable.

Prioriza las pruebas según:

  • Importancia para el negocio.
  • Impacto en seguridad.
  • Impacto en el usuario.
  • Complejidad.
  • Frecuencia de uso.
  • Probabilidad de fallo.
  • Costo del fallo.

Los flujos de trabajo importantes merecen pruebas significativas incluso cuando el porcentaje de cobertura general ya es alto.

19. Pruebas de Rendimiento

Verifica el rendimiento del frontend cuando sea relevante.

Considera:

  • Carga de página.
  • Ejecución de JavaScript.
  • Rendimiento de renderizado.
  • Listas grandes.
  • Carga de imágenes.
  • Solicitudes de red.
  • Tamaño del bundle.
  • Capacidad de respuesta de la interacción.

Usa las herramientas de rendimiento del navegador apropiadas y las herramientas del proyecto establecidas.

No hagas afirmaciones de rendimiento sin mediciones o evidencia de respaldo.

20. Pruebas de Frontend Orientadas a Seguridad

Incluye pruebas que verifiquen comportamientos sensibles a la seguridad.

Considera:

  • Contenido generado por el usuario no seguro.
  • Fallos de autenticación.
  • Navegación no autorizada.
  • Datos sensibles que aparecen en la interfaz.
  • Redireccionamientos no seguros.
  • Respuestas de API inesperadas.
  • Cargas de archivos inválidas.
  • Credenciales expuestas.
  • Mensajes de error inapropiados.

No expongas secretos o información sensible en la salida de las pruebas.

Usa únicamente entornos de prueba autorizados.

21. Depuración de Pruebas Fallidas

Cuando una prueba falla:

  1. Lee el mensaje de fallo completo.
  2. Identifica la prueba que falla.
  3. Reproduce el fallo.
  4. Inspecciona el componente afectado y las dependencias.
  5. Determina si el problema está en la aplicación o en la prueba.
  6. Implementa la corrección adecuada.
  7. Vuelve a ejecutar la prueba que falla.
  8. Ejecuta pruebas relacionadas.
  9. Verifica regresiones.

No cambies los resultados esperados solo para que una prueba pase a menos que la expectativa original fuera incorrecta.

No suprimas fallos sin explicar por qué.

22. Integración Continua

Donde haya CI configurado, integra las pruebas de frontend en el flujo de trabajo de desarrollo.

Las etapas de validación típicas incluyen:

Cambios de código
     |
     v
Instalación de dependencias
     |
     v
Análisis estático
     |
     v
Pruebas unitarias y de componentes
     |
     v
Validación de compilación
     |
     v
Pruebas de integración / E2E
     |
     v
Aprobación de despliegue

Usa la plataforma y configuración de CI existente del repositorio.

Ejemplos incluyen GitHub Actions y otros sistemas de CI.

No introduzcas una nueva plataforma de CI innecesariamente.

Asegúrate de que las comprobaciones fallidas requeridas sean visibles y no permitan que compilaciones inválidas pasen silenciosamente.

23. Flujo de Trabajo de Desarrollo

Sigue este flujo de trabajo al realizar tareas de prueba de frontend.

Fase 1: Comprender

  • Lee los requisitos.
  • Inspecciona la aplicación.
  • Identifica flujos de trabajo críticos.
  • Identifica pruebas existentes.
  • Comprende el entorno de prueba.

Fase 2: Planificar

  • Elige los niveles de prueba apropiados.
  • Identifica escenarios de prueba.
  • Identifica los datos de prueba necesarios.
  • Identifica dependencias y simulaciones.
  • Prioriza la funcionalidad de alto riesgo.

Fase 3: Implementar

  • Escribe pruebas enfocadas.
  • Usa las convenciones de prueba existentes.
  • Mantén los datos de prueba controlados.
  • Evita cambios innecesarios en el framework.
  • Documenta suposiciones importantes.

Fase 4: Ejecutar

  • Ejecuta las pruebas relevantes.
  • Ejecuta pruebas de regresión relacionadas.
  • Ejecuta análisis estático donde esté configurado.
  • Ejecuta la compilación de producción.
  • Ejecuta pruebas de navegador cuando sea necesario.

Fase 5: Investigar

  • Analiza los fallos.
  • Corrige defectos en la aplicación o pruebas incorrectas.
  • Vuelve a ejecutar las pruebas afectadas.
  • Verifica la funcionalidad relacionada.

Fase 6: Informar

Informa:

  • Pruebas creadas.
  • Escenarios de prueba cubiertos.
  • Comandos ejecutados.
  • Pruebas superadas.
  • Pruebas fallidas.
  • Limitaciones conocidas.
  • Riesgos restantes.

Nunca informes pruebas como superadas a menos que se hayan ejecutado realmente con éxito.

24. Prácticas Prohibidas

Nunca:

  • Asumas que el código funciona sin verificación.
  • Ignores pruebas fallidas.
  • Deshabilites pruebas importantes para obtener una compilación exitosa.
  • Uses simulaciones poco realistas para ocultar defectos.
  • Dependas de datos de usuario de producción para pruebas ordinarias.
  • Expongas secretos en archivos de prueba.
  • Uses retrasos arbitrarios como sustituto de una sincronización adecuada.
  • Afirmes cobertura completa sin evidencia.

25. Regla Final

Prueba el comportamiento real de la aplicación.

No confíes en la implementación; confía en la evidencia.

No asumas que el código funciona porque parece correcto.

El objetivo de la skill es encontrar y prevenir defectos, no simplemente producir pruebas.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Skills relacionados