unit-testing - unitarias - unit test c# visual studio 2017
¿Mi código realmente no es verificable por unidad? (7)
Un montón de código en un proyecto actual está directamente relacionado con mostrar cosas usando un motor de renderizado 3D de terceros. Como tal, es fácil decir "este es un caso especial, no puede probarlo por unidad". Pero me pregunto si esta es una excusa válida ... es fácil pensar que "soy especial", pero rara vez es así.
¿Hay tipos de código que realmente no son adecuados para pruebas de unidad? Por adecuado, me refiero a que "sin tardar más en averiguar cómo escribir la prueba vale el esfuerzo" ... tratar con una tonelada de matemática / renderización 3D podría llevar mucho trabajo demostrar la salida de una función. Es correcto en comparación con solo mirar los gráficos renderizados.
Bueno, no puedes hacer pruebas unitarias de ciertos tipos de códigos de excepción, pero aparte de eso ...
Tengo pruebas de unidad verdaderas para un código que parece imposible incluso para conectar un arnés de prueba y un código que parece que debería ser comprobable por la unidad pero no lo es.
Una de las formas en que sabe que su código no es comprobable por unidad es cuando depende de las características físicas del dispositivo en el que se ejecuta. Otro tipo de código no verificable por unidad es el código directo de la interfaz de usuario (y encuentro muchos cortes en el código directo de la interfaz de usuario).
También tengo una gran cantidad de código no comprobable por unidad que tiene las pruebas de integración adecuadas.
Creo que esta es una buena pregunta. Lucho con esto todo el tiempo, y parece que hay ciertos tipos de código que encajan en el paradigma de prueba de unidad y otros tipos que no lo hacen.
Lo que considero claramente comprobable por unidad es un código que obviamente tiene espacio para estar equivocado . Ejemplos:
Código para calcular matemáticas vasculares o funciones de álgebra lineal. Siempre escribo una función auxiliar para verificar las respuestas y la ejecuto de vez en cuando.
Código de estructura de datos peludos, con referencias cruzadas, guías, punteros hacia atrás y métodos para mantenerlo consistente de manera incremental. Estos son realmente fáciles de romper, por lo que las pruebas unitarias son buenas para ver si se rompen.
Por otro lado, en el código con poca redundancia, si el código se compila puede no estar claro lo que significa estar equivocado. Por ejemplo, hago IU bastante complicadas utilizando diálogos dinámicos , y no está claro qué probar. Todo el tipo de cosas, como el manejo de eventos, el diseño y la visualización / ocultación / actualización de controles que podrían hacer que este código sea propenso a errores, simplemente se tratan en una capa bien verificada debajo.
El tipo de prueba que necesito más que la prueba de unidad es la prueba de cobertura. ¿He probado todas las características posibles y combinaciones de características? Ya que este es un espacio muy grande y es prohibitivo escribir pruebas automatizadas para cubrirlo, a menudo me encuentro haciendo pruebas de monte-carlo, donde las selecciones de funciones se eligen al azar y se envían al sistema. Luego se examina el resultado de forma automática y / o manual.
Divida la representación en pasos y pruebe comparando el buffer de cuadros para cada paso con una buena imagen conocida.
No importa lo que tenga, se puede dividir en números que pueden compararse. El verdadero truco es cuando tienes un generador de números aleatorios en el algoritmo, o alguna otra parte no determinista.
Con cosas como el punto flotante, es posible que deba restar los datos generados de los datos esperados y verificar que la diferencia sea menor que un umbral de error.
El código que se relaciona directamente con la visualización de información, la generación de imágenes e incluso cosas generales de IU, a veces es difícil de probar por unidad.
Sin embargo, eso se aplica principalmente al nivel más alto de ese código. Por lo general, las llamadas al método 1-2 debajo de la "superficie" es un código que se prueba fácilmente por unidad.
Por ejemplo, puede que no sea trivial probar que alguna información está correctamente animada en el cuadro de diálogo cuando falla una validación. Sin embargo, es muy fácil verificar si la validación fallará para alguna entrada dada.
Asegúrese de estructurar su código de manera que el área de superficie "no verificable" esté bien separada de la prueba y escriba pruebas exhaustivas para el código de no superficie.
El punto de prueba de unidad de su código de representación no es demostrar que el código de terceros hace lo correcto (que es para pruebas de integración y regresión). El punto es demostrar que su código da las instrucciones correctas al código de terceros. En otras palabras, solo tiene que controlar la entrada de su capa de código y verificar la salida (que se convertiría en la entrada del renderizador).
Por supuesto, puede crear una versión simulada del renderizador que haga gráficos ASCII baratos o algo así, y luego verificar los pseudogramas si así lo desea y esto hace que la prueba sea más clara si lo desea, pero no es estrictamente necesario para una prueba unitaria de su código.
Si no puede dividir su código en unidades, es muy difícil realizar una prueba unitaria. Supongo que si tiene funciones atómicas 3D (por ejemplo, traducir, rotar y proyectar un punto) deberían ser fácilmente comprobables: cree un conjunto de puntos de prueba y compruebe si la transformación lleva un punto hacia donde debería. Si solo puede alcanzar el código 3D a través de una API limitada, sería difícil probarlo. Por favor, vea las publicaciones de Misko Hevery Testability y su guía de testability .
Si puedes tomar la imagen renderizada, puedes probarlo por unidad.
Simplemente renderice algunas imágenes con el código base actual, vea si "se ven bien" (examinándolas hasta el píxel si es necesario) y guárdelas para compararlas. Sus pruebas de unidad podrían compararse con las imágenes almacenadas y ver si el resultado es el mismo.
Si esto vale la pena o no, eso lo decides tú.