---
title: Pruebas y depuración
description: Flujos de trabajo de pruebas y depuración con Verdent
---
Verdent for VS Code te ayuda a escribir pruebas exhaustivas y a depurar problemas mediante ciclos multipass de generación, prueba y reparación, análisis de errores y mejoras automatizadas de la cobertura de pruebas. Genera pruebas unitarias, de integración y de extremo a extremo que coinciden con el framework y el estilo de pruebas de tu proyecto.
### Lo que aprenderás
- Generar pruebas unitarias que cubran casos límite y el comportamiento esperado
- Trabajar con todos los frameworks de pruebas principales (Jest, Pytest, JUnit, etc.)
- Crear pruebas de integración que verifiquen flujos de trabajo de varios componentes
- Mejorar la cobertura de pruebas identificando y probando rutas de código no cubiertas
- Depurar problemas mediante el análisis de mensajes de error y el rastreo de la ejecución
- Diagnosticar errores a partir de stack traces, registros de errores y comportamientos inesperados
### Requisitos previos
Antes de probar y depurar con Verdent:
- Visual Studio Code con la extensión Verdent instalada
- Una base de código o un espacio de trabajo de proyecto abierto en VS Code
- Un plan de suscripción activo de Verdent con créditos disponibles
- Un framework de pruebas configurado en tu proyecto (opcional para la generación de pruebas)
---
## Escritura de pruebas unitarias
Verdent genera pruebas unitarias que coinciden con el framework y el estilo de pruebas de tu proyecto. Analiza las pruebas existentes para comprender tus patrones y luego genera pruebas con la configuración, las aserciones y el mocking adecuados.
**Ejemplo:**
```
Write unit tests for the calculateDiscount function
```
Verdent hará lo siguiente:
- Examinar la implementación de la función `calculateDiscount`
- Identificar los parámetros de entrada y los valores de retorno
- Analizar las pruebas existentes para coincidir con tus convenciones (estructura de las pruebas, estilo de aserción, patrones de nomenclatura)
- Generar pruebas que cubran:
- **Ruta feliz**: entradas válidas con salidas esperadas
- **Casos límite**: valores de frontera, cero, números negativos, valores máximos
- **Entradas no válidas**: null, undefined, tipos incorrectos
- **Comportamiento esperado**: validación de la lógica de negocio
**Estructura de las pruebas generadas:**
Verdent crea pruebas siguiendo los patrones de tu proyecto:
- **Organización de la suite de pruebas**: bloques describe, clases de prueba o estructura de módulos
- **Configuración y limpieza**: hooks before/after que coinciden con tus pruebas existentes
- **Aserciones**: usando la biblioteca de aserciones de tu proyecto (expect, assert, should, etc.)
- **Mocking**: coincidiendo con tus patrones de mocking (jest.mock, sinon, unittest.mock)
- **Convenciones de nomenclatura**: nombres de pruebas que siguen el estilo establecido
**Ciclos multipass de generación, prueba y reparación:**
Para realizar pruebas exhaustivas, Verdent usa ciclos multipass:
1. **Generar**: crear la suite de pruebas inicial
2. **Ejecutar**: ejecutar las pruebas para verificar que funcionan
3. **Reparar**: corregir las pruebas que fallan o mejorar la cobertura
4. **Iterar**: repetir hasta que las pruebas pasen y la cobertura sea suficiente
Esto garantiza que las pruebas no solo se escriban, sino que realmente funcionen correctamente con tu base de código.
Verdent analiza tus pruebas existentes para coincidir con tus convenciones. Cuanto más consistentes sean tus patrones de prueba existentes, mejor se alinearán las pruebas generadas por Verdent con el estilo de tu proyecto.
---
## Frameworks de pruebas compatibles
Verdent es compatible con todos los frameworks de pruebas principales en distintos lenguajes de programación y pilas tecnológicas sin requerir configuración adicional.
**Frameworks de pruebas unitarias:**
```javascript Jest
test('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Mocha
const assert = require('assert');
describe('sum', () => {
it('returns correct result', () => {
assert.strictEqual(sum(2, 3), 5);
});
});
```
```javascript Vitest
import { describe, it, expect } from 'vitest';
it('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Jasmine
describe('sum', () => {
it('returns correct result', () => {
expect(sum(2, 3)).toEqual(5);
});
});
```
**Pruebas específicas de frameworks:**
- **React Testing Library**: pruebas de componentes de React centradas en el usuario
- **Vue Test Utils**: biblioteca oficial de pruebas de Vue.js
**Pruebas de extremo a extremo:**
- **Cypress**: pruebas de extremo a extremo y de componentes
- **Playwright**: pruebas de extremo a extremo entre navegadores
- **Puppeteer**: pruebas con Chrome headless
- **Pytest**: el framework de pruebas de Python más popular
- **unittest**: framework de pruebas integrado de Python
- **nose2**: amplía unittest con plugins
- **doctest**: pruebas integradas en docstrings
Verdent genera pruebas con fixtures, parametrización y patrones de aserción adecuados que coinciden con tu estilo de pruebas de Python.
- **JUnit**: framework de pruebas estándar de Java (JUnit 4, JUnit 5)
- **TestNG**: framework de pruebas con funciones avanzadas
- **Mockito**: framework de mocking para Java
- **AssertJ**: biblioteca de aserciones fluidas
Verdent crea pruebas con anotaciones, métodos de ciclo de vida y aserciones que siguen las convenciones de pruebas de Java.
- **RSpec** (Ruby): framework de desarrollo guiado por comportamiento
- **PHPUnit** (PHP): framework de pruebas unitarias para PHP
- **Go testing** (Go): paquete de pruebas integrado de Go
- **xUnit** (C#/.NET): framework de pruebas para .NET
- **Catch2** (C++): framework de pruebas moderno de C++
Verdent se adapta a los modismos de pruebas de tu lenguaje y genera pruebas que coinciden con las convenciones de tu proyecto.
Verdent reconoce tu framework de pruebas a partir de la configuración de tu proyecto y de las pruebas existentes, y genera automáticamente pruebas que coinciden con tu configuración.
---
## Generación de pruebas de integración
Verdent genera pruebas de integración que verifican cómo funcionan juntos varios componentes, servicios o módulos. Crea pruebas que simulan flujos de trabajo reales, incluidas interacciones con API, operaciones de base de datos, flujos de autenticación y recorridos de usuario de varios pasos.
**Ejemplo:**
```
Write integration tests for the user registration flow
```
Verdent genera pruebas que verifican el flujo completo:
1. **Envío del formulario**: el usuario envía el formulario de registro con datos válidos
2. **Validación**: el backend valida el formato del correo electrónico, la fortaleza de la contraseña y la integridad de los datos
3. **Inserción en la base de datos**: se crea el registro del usuario en la base de datos
4. **Envío de correo electrónico**: se envía el correo de confirmación (simulado o real)
5. **Inicio de sesión exitoso**: el nuevo usuario puede iniciar sesión de inmediato con sus credenciales
**Estructura de las pruebas de integración:**
Verdent crea pruebas de integración con:
- **Configuración de la prueba**: carga de datos en la base de datos, inicialización de servicios, creación de datos de prueba
- **Simulación del flujo de trabajo**: operaciones de varios pasos en secuencia
- **Verificación del estado**: comprobación del estado de la base de datos, respuestas de API y efectos secundarios
- **Mocking de servicios externos**: servicios de correo electrónico, API de pagos, integraciones de terceros
- **Limpieza de la prueba**: eliminación de datos de prueba, rollback de la base de datos, apagado de servicios
**Ejemplos de escenarios de prueba:**
```
Write integration tests for the checkout and payment process
```
Verdent prueba:
- Agregar artículos al carrito
- Aplicar códigos de descuento
- Calcular totales con impuestos y envío
- Procesar el pago (con una pasarela de pago simulada)
- Crear el registro del pedido en la base de datos
- Enviar el correo de confirmación
- Actualizar el inventario
**Aislamiento de las pruebas:**
Verdent garantiza que las pruebas de integración estén correctamente aisladas:
- Cada prueba comienza con un estado limpio de la base de datos
- Las llamadas a servicios externos se simulan para evitar efectos secundarios
- Las pruebas pueden ejecutarse en cualquier orden sin dependencias
- La limpieza ocurre incluso si las pruebas fallan
Las pruebas de integración se benefician de entornos de prueba aislados; Verdent puede ayudar a configurar fixtures de base de datos y simular servicios externos.
Las pruebas de integración verifican que los componentes funcionen correctamente en conjunto. Son más complejas que las pruebas unitarias, pero ofrecen mayor confianza en que los flujos de trabajo del mundo real funcionan como se espera.
---
## Mejora de la cobertura de pruebas
Verdent analiza tu base de código para identificar funciones, ramas y casos límite no probados, y luego genera pruebas para mejorar la cobertura. Examina tu suite de pruebas existente e identifica las brechas donde no se ejercitan las rutas de código.
**Ejemplo:**
```
Analyze test coverage and write tests for uncovered code paths in the payment module
```
Verdent hará lo siguiente:
1. **Analizar las pruebas existentes**: examinar qué se prueba actualmente
2. **Identificar brechas de cobertura**: encontrar funciones específicas, ramas condicionales, rutas de manejo de errores y casos límite que carecen de pruebas
3. **Generar las pruebas faltantes**: crear pruebas dirigidas al código no cubierto
4. **Verificar la mejora de la cobertura**: ejecutar las pruebas para confirmar que la cobertura aumenta
**Lo que identifica Verdent:**
- **Funciones no probadas**: funciones sin ninguna cobertura de prueba
- **Ramas condicionales**: instrucciones if/else donde una rama no se prueba
- **Rutas de manejo de errores**: bloques try/catch o callbacks de error sin pruebas de fallo
- **Casos límite**: valores de frontera, manejo de null/undefined, coerción de tipos
- **Puntos de integración**: llamadas a API, operaciones de base de datos, interacciones con servicios externos
**Ejemplo de mejora de la cobertura:**
```
Improve test coverage for the UserService class
```
Verdent identifica:
- `getUserById` tiene pruebas para identificadores válidos pero no para identificadores no válidos
- `updateUser` carece de pruebas para fallos de validación
- `deleteUser` carece de pruebas para comprobaciones de autorización
- Las rutas de manejo de errores en `createUser` no están probadas
Luego genera pruebas dirigidas específicamente a estas brechas, aumentando la cobertura del 65 % al 95 %.
**Métricas de cobertura:**
Verdent te ayuda a alcanzar porcentajes de cobertura más altos y a detectar posibles errores en código que antes no estaba probado:
- **Cobertura de líneas**: porcentaje de líneas de código ejecutadas por las pruebas
- **Cobertura de ramas**: porcentaje de ramas condicionales probadas
- **Cobertura de funciones**: porcentaje de funciones con al menos una prueba
- **Cobertura de sentencias**: porcentaje de sentencias ejecutadas
---
## Depuración con Verdent
Verdent ayuda a depurar analizando mensajes de error, rastreando el flujo de ejecución, identificando las causas raíz y sugiriendo correcciones. Pega registros de errores, describe comportamientos inesperados o pide a Verdent que investigue problemas específicos.
Describe qué está mal y qué esperabas:
```
This function returns undefined instead of the user object. Debug it.
```
Verdent hará lo siguiente:
- Leer la implementación de la función
- Rastrear el flujo de ejecución
- Identificar dónde la ruta del código falla (falta una sentencia return, condicional incorrecto, problema de async/await)
- Proponer una corrección con su explicación
- Sugerir casos de prueba para evitar regresiones
**Ejemplo:**
```
The login form redirects to the home page even when credentials are invalid
```
Verdent hará lo siguiente:
- Examinar la lógica de envío del formulario de inicio de sesión
- Rastrear el flujo de autenticación
- Identificar el error (la redirección ocurre antes de que se complete la validación asíncrona)
- Proponer una corrección (esperar la validación antes de redirigir)
Solicita un análisis de rendimiento:
```
The product search is slow when the database has 10,000+ products
```
Verdent hará lo siguiente:
- Analizar la implementación de la consulta de búsqueda
- Identificar la ineficiencia (consultas N+1, falta de índice en la base de datos, algoritmo ineficiente)
- Sugerir una optimización (agregar un índice en la base de datos, agrupar consultas, almacenar resultados en caché)
La depuración de rendimiento ayuda a identificar cuellos de botella en algoritmos, consultas de base de datos o respuestas de API que ralentizan tu aplicación.
Comprende cómo se ejecuta el código:
```
Why does this API endpoint return a 500 error when the email parameter is missing?
```
Verdent hará lo siguiente:
- Rastrear el manejo de la solicitud desde el endpoint hasta la validación y la base de datos
- Identificar dónde ocurre el error (acceso a una propiedad de undefined)
- Explicar por qué ocurre el error (falta una comprobación de null antes de acceder a la propiedad)
- Sugerir una corrección defensiva (validar los parámetros antes de usarlos)
El rastreo del flujo de ejecución te ayuda a comprender la ruta que sigue tu código y dónde se desvía del comportamiento esperado.
Pega los mensajes de error o los stack traces directamente en el chat. Verdent analiza el error, localiza el código problemático y explica qué salió mal con rutas de archivo y números de línea específicos.
---
## Diagnóstico a partir de mensajes de error y registros
Pega mensajes de error, stack traces o archivos de registro directamente en el chat. Verdent analiza el error, identifica el archivo de origen y el número de línea, explica la causa y sugiere una corrección.
Pega los mensajes de error y los stack traces:
```
TypeError: Cannot read property 'name' of undefined
at UserProfile.render (UserProfile.jsx:45)
at processComponent (react-dom.js:2103)
```
Pega esto en Verdent:
```
I'm getting this error: [paste stack trace]
```
Verdent hará lo siguiente:
- Identificar el tipo de error (TypeError por acceso a null/undefined)
- Localizar la línea exacta (`UserProfile.jsx:45`)
- Leer el código en esa ubicación
- Explicar por qué ocurre (el objeto user es undefined antes de que se carguen los datos)
- Proponer correcciones:
- Agregar una comprobación de null: `if (!user) return `
- Usar encadenamiento opcional: `user?.name`
- Asegurar que los datos se carguen antes de renderizar el componente
Pega archivos de registro o la salida de consola para analizarlos:
```
Analyze these logs and tell me why the API requests are failing:
[paste 50 lines of log output]
```
Verdent hará lo siguiente:
- Escanear los registros en busca de patrones de error
- Identificar fallos de autenticación, tiempos de espera de red o errores de base de datos
- Rastrear la secuencia de eventos que conduce al fallo
- Sugerir correcciones según el patrón de error
El análisis de registros ayuda a identificar patrones a través de múltiples fallos y a comprender la secuencia de eventos que conduce a los errores.
Para problemas complejos, Verdent usa la depuración de varios pasos:
1. **Analizar los registros de errores** para identificar el punto de fallo
2. **Leer el código relevante** para comprender la implementación
3. **Rastrear el flujo de ejecución** para encontrar dónde fallan las cosas
4. **Sugerir correcciones** con ejemplos de código
5. **Generar pruebas** para evitar regresiones
**Ejemplo:**
```
The shopping cart total is sometimes incorrect. Here are the error logs: [paste logs]
```
Verdent hará lo siguiente:
1. Analizar los registros e identificar cuándo ocurre el error (cuando se aplican códigos de descuento)
2. Leer la lógica de cálculo de descuentos
3. Identificar el error (el descuento se calcula antes de los impuestos, no después)
4. Proponer una corrección (reordenar los pasos de cálculo)
5. Sugerir casos de prueba (carrito con descuento, carrito con impuestos, carrito con ambos)
---
## Prácticas recomendadas
Escribe pruebas a medida que desarrollas funciones, no después de completarlas. Verdent puede generar pruebas inmediatamente después de crear nuevas funciones o componentes.
Verdent coincide con los patrones de prueba de tu proyecto. Mantén una estructura de prueba consistente para que Verdent genere pruebas que se alineen con tus convenciones.
Pide a Verdent que pruebe condiciones de frontera, escenarios de error y entradas inusuales: "Escribe pruebas que incluyan casos límite para entradas no válidas y valores de frontera."
No parafrasees los errores. Pega el stack trace completo para un diagnóstico preciso y una resolución más rápida.
Al depurar, indica claramente qué esperabas que ocurriera y qué ocurrió en realidad. Este contexto ayuda a Verdent a identificar la causa raíz.
Para funciones críticas, solicita una generación exhaustiva de pruebas con ciclos multipass: "Genera pruebas exhaustivas para el módulo de pagos y verifica que todas pasen."
Después de refactorizar el código, solicita pruebas para verificar que la funcionalidad se conserva: "Genera pruebas para verificar que el módulo de autenticación refactorizado funciona correctamente."
Después de corregir un error, solicita una prueba para evitar regresiones: "Escribe una prueba que garantice que este error no vuelva a ocurrir."
---
## Consulta también
Aprende a escribir nuevas funciones con la asistencia de IA de Verdent
Mejora la calidad del código mediante flujos de trabajo de refactorización seguros