🔥 PRUEBAS, COBERTURA DEL CÓDIGO

¿Qué es la cobertura de código en Go?

La cobertura de código es un indicador fundamental para evaluar qué porcentaje de nuestro software ha sido verificado mediante pruebas automatizadas. En el contexto de Go, aplicar mejores prácticas para cobertura de código en Go permite asegurar que los distintos caminos lógicos de la aplicación han sido validados, lo que contribuye a identificar y corregir posibles fallas antes de que se conviertan en problemas reales.

package robot

import "fmt"

func Controlador(i int) (comando string, err error) {
    err = nil
    switch i {
    case 100:
        comando = "encender"
        break
    case 200:
        comando = "apagar"
        break
    case 300:
        comando = "avanzar"
        break
    case 400:
        comando = "saludar"
        break
    default:
        comando = ""
        err = fmt.Errorf("Opción invalida")
    }
    return
}

En este ejemplo, se presenta una función Controlador que opera un robot a partir de un código numérico, devolviendo el comando correspondiente como texto. El uso de un switch permite gestionar todas las instrucciones posibles, mientras que el caso por defecto maneja entradas no reconocidas.

Para garantizar la calidad y robustez del código, es esencial diseñar pruebas que cubran todos los escenarios posibles. Una estrategia efectiva es utilizar una tabla de pruebas, lo que facilita la creación de pruebas exhaustivas en proyectos Go.

package robot

import "testing"

type ControladorTest struct {
    codigo int
    want   string
}

var controladorTests = []ControladorTest{
    {codigo: 100, want: "encender"},
    {codigo: 200, want: "apagar"},
    {codigo: 300, want: "avanzar"},
    {codigo: 400, want: "saludar"},
    {codigo: 500, want: ""},
}

func TestControladorTests(t *testing.T) {
    for _, test := range controladorTests {
        got, _ := Controlador(test.codigo)
        if got != test.want {
            t.Errorf("Controlador(%v) = %v, se esperaba %v", test.codigo, got, test.want)
        }
    }
}

Una vez que se han cubierto todos los casos relevantes, se puede ejecutar la prueba utilizando la instrucción cover para obtener el porcentaje de cobertura alcanzado. Esto es clave para quienes buscan cómo mejorar la cobertura de pruebas en Golang y desean implementar procesos de calidad en sus desarrollos.

go test -cover

Si todas las rutas del código están cubiertas, la salida será del 100%:

PASS
coverage: 100.0% of statements

Modificar la tabla de pruebas, por ejemplo comentando alguna línea, permite observar cómo disminuye el porcentaje de cobertura. Así, se puede ajustar el conjunto de pruebas para lograr una validación más completa.

¿Cuáles son las mejores prácticas para cobertura de código en Go?

• Escribe pruebas unitarias pequeñas y enfocadas: Cada función debe tener pruebas que validen tanto los casos esperados como los bordes y errores.
• Utiliza tablas de pruebas: Facilitan la cobertura de múltiples escenarios y reducen la duplicidad de código en los tests.
• Aprovecha subtests (t.Run): Permiten identificar fácilmente qué casos fallan y organizan mejor los resultados.
• Cubre tanto caminos felices como errores: No solo pruebes el funcionamiento correcto, también los errores y condiciones límite.
• Integra la cobertura en CI/CD: Automatiza la ejecución de go test -cover en pipelines para evitar regresiones.
• Apóyate en herramientas como go tool cover: Visualiza gráficamente qué líneas no están cubiertas y enfoca tus esfuerzos.
• Evita perseguir el 100% de cobertura ciega: Prioriza la cobertura de lógica crítica y caminos relevantes, no el simple número.
• Refactoriza el código difícil de probar: Si una función es difícil de testear, probablemente necesita ser simplificada o dividida.
• Revisa y actualiza las pruebas con cada cambio: Mantén las pruebas alineadas con la evolución del código.
• Documenta los casos no cubiertos intencionalmente: Si decides no cubrir ciertos caminos, justifica la razón en los comentarios.

Aplicando estas prácticas, mejorarás la calidad, mantenibilidad y confiabilidad de tus proyectos en Go.

Conclusión

La cobertura de código es una métrica esencial para cualquier equipo de desarrollo que busque entregar software confiable y de alta calidad. Implementar pruebas automatizadas y medir su alcance permite detectar errores de forma temprana, optimizando el ciclo de desarrollo y reduciendo riesgos en producción. Adoptar mejores prácticas para cobertura de código en Go y utilizar herramientas imprescindibles para cualquier desarrollador Go no solo incrementa la confianza en el producto final, sino que también fomenta una cultura de mejora continua. En definitiva, dedicar tiempo a cómo mejorar la cobertura de pruebas en Golang es una inversión que se traduce en aplicaciones más robustas, seguras y mantenibles a largo plazo.

Cuestionario de repaso

1. ¿Qué es la cobertura de código y cómo se interpreta su porcentaje en los reportes de Go?
2. Explica el propósito y uso de la instrucción go test -cover. ¿Qué información relevante proporciona?
3. ¿Por qué es recomendable utilizar tablas de pruebas en los tests de Go? Da un ejemplo de su ventaja.
4. ¿Cómo puedes identificar visualmente las líneas no cubiertas por pruebas en un proyecto Go?
5. ¿Qué prácticas ayudan a mantener una cobertura de código relevante y no solo perseguir el 100%?
6. ¿Cómo se integran las métricas de cobertura en un pipeline de CI/CD y por qué es importante?
7. ¿Qué tipo de caminos o escenarios deben priorizarse al escribir pruebas para maximizar el valor de la cobertura?
8. Menciona dos herramientas adicionales (además de go test -cover) que ayudan a analizar la cobertura de código en Go.
9. ¿Qué acciones tomarías si una función resulta difícil de cubrir con pruebas?
10. ¿Por qué es importante documentar los casos no cubiertos intencionalmente en el código?