qué tipo de funciones y / o clases son imposibles de probar y por qué

La principal excusa del desarrollador para no tener una buena unidad de prueba es "El código no está diseñado de manera comprobable". Estoy tratando de entender qué tipo de diseño y código no se pueden probar en la unidad.

Varios factores pueden dificultar la prueba unitaria del código. Cuando este es el caso, la refactorización ayuda a mejorar el código para que sea comprobable.

Algunos ejemplos de código que probablemente serían difíciles de probar:

• Una función 1000-LOC,
• Código que depende en gran medida del estado global,
• El código que requiere concreto, complica la creación de objetos, como el contexto de la base de datos, en lugar de depender de las interfaces y la inyección de dependencias,
• Código que funciona lentamente ,
• Código de espagueti,
• Código heredado que se modificó durante años sin preocuparse por la legibilidad o la facilidad de mantenimiento,
• Código difícil de entender que no tiene comentarios o sugerencias sobre la intención original del autor (por ejemplo, código que usa nombres de variables como function pGetDp_U(int i, int i2, string sText).

Tenga en cuenta que la falta de una arquitectura clara no hace que el código sea difícil de probar, ya que las pruebas unitarias se refieren a pequeñas partes del código. La arquitectura poco clara aún tendría un impacto negativo en la integración y las pruebas del sistema.

Hay muchas cosas que dificultan la prueba unitaria del código. Casualmente, muchos de ellos también dificultan el mantenimiento del código:

• Ley de infracciones de Demeter .
• Crear objetos dentro de un método en lugar de inyectar dependencias .
• Acoplamiento apretado.
• Mala cohesión.
• Se basa en gran medida en los efectos secundarios.
• Se basa en gran medida en globales o singletons.
• No expone muchos resultados intermedios. (Una vez tuve que probar una función matemática de diez páginas con una sola salida y sin resultados intermedios disponibles. Mis predecesores básicamente codificaron cualquier respuesta que el código me diera).
• Depende en gran medida y directamente de los servicios que son difíciles de burlar, como las bases de datos.
• El entorno de tiempo de ejecución es significativamente diferente del entorno de desarrollo, como un objetivo incrustado.
• Las unidades solo están disponibles en forma compilada (como una DLL de terceros).

Ejemplos comunes de código que las personas no desean realizar pruebas unitarias:

• Código que interactúa directamente con E / S (lectura de archivos, llamadas directas a la red, ...).
• Código que actualiza directamente la interfaz de usuario.
• Código que hace referencia directamente a objetos únicos u objetos globales.
• Código que cambia implícitamente el estado del objeto o subobjeto.

Usando un marco simulado, todos estos ejemplos pueden ser probados en unidades. Es solo trabajo configurar los reemplazos simulados para las dependencias internas.

Cosas que realmente no pueden ser probadas:

• Bucles infinitos (para un administrador de hilos, controlador o algún otro tipo de código de ejecución larga)
• Ciertos tipos de operaciones de ensamblaje directo (que admiten algunos idiomas)
• Código que requiere acceso privilegiado (no imposible, simplemente no es una buena idea)

Hay algunas áreas que pueden dificultar la escritura de pruebas unitarias. Sin embargo, quisiera enfatizar que eso no significa que deba descartar técnicas útiles directamente porque simplemente pueden agregar cierta complejidad a sus pruebas. Al igual que con cualquier codificación , debe hacer su propio análisis para determinar si los beneficios superan los costos, y no aceptar ciegamente lo que publica un tipo aleatorio en la red.

Mal escrito del código diseñado

• acoplamiento inapropiado (generalmente acoplamiento apretado donde no debería estar)
• código de fregadero de cocina (donde una función tiene demasiada lógica / responsabilidades)

La dependencia del estado en un ámbito diferente

El costo para la mayoría de estas espirales está fuera de control a menos que sepa qué está haciendo. Desafortunadamente, muchos a menudo no saben cómo usar estas técnicas para mitigar cosas como la complejidad de las pruebas.

• Singletons
• Globales
• Cierres

Externo / Estado del sistema

• Dependencias de hardware / dispositivo
• Dependencias de red
• Dependencias del sistema de archivos
• Dependencias entre procesos
• Otras dependencias de llamadas al sistema

Concurrencia

• Roscado (cerraduras, secciones críticas, etc.)
• tenedor
• Corutinas
• Llamadas de respaldo
• Controladores de señal (no todos, pero algunos)

No existe un código que no pueda probarse. Sin embargo, hay algunos ejemplos de código que es REALMENTE, REALMENTE difícil de probar (hasta el punto de que posiblemente no valga la pena):

Interacciones de hardware: si el código manipula directamente el hardware (por ejemplo, escribir en un registro para mover un dispositivo físico), la prueba de la unidad puede ser demasiado difícil o costosa. Si usa hardware real para la prueba, eso puede ser costoso para obtener retroalimentación apropiada en el arnés de prueba (¡aún más equipo!), Y si no lo hace, debe emular el comportamiento exacto de los objetos físicos, no es un truco pequeño. algunas instancias

Interacciones del reloj: esto suele ser más fácil, porque casi siempre es posible burlarse de las funciones del reloj del sistema de manera bastante trivial. Pero cuando no puede hacerlo, estas pruebas se vuelven inmanejables: las pruebas que se basan en tiempo real tienden a tardar mucho tiempo en ejecutarse y, en mi experiencia, tienden a ser muy frágiles ya que las cargas del sistema hacen que las cosas tarden más de lo debido , causando fallas en la prueba fantasma.

Mis tres grupos principales para esto son:

• código que depende de servicios externos

• sistemas que no permiten que los evaluadores modifiquen el estado independientemente de la aplicación.

• entornos de prueba que no replican la configuración de producción.

Esto es lo que más he experimentado como desarrollador convertido en ingeniero de control de calidad.