tipos - test en java

¿Con qué frecuencia debemos escribir pruebas unitarias? (12)

Mi mentor / líder de desarrollo me pide que escriba un nuevo caso de prueba de unidad para un flujo de control recién escrito

¿Cómo se escribió ese flujo de control, a menos que fuera necesario para pasar una prueba que falla? Según la definición de TDD , ningún código de producción llegará a existir, a menos que primero exista una prueba fallida que requiera que se escriba ese fragmento de código. Por lo tanto, debe haber escrito el código utilizando alguna técnica de última prueba y no TDD.

Le recomiendo que lea el artículo El arte del desarrollo ágil: desarrollo guiado por pruebas . Puedes practicar TDD usando este tutorial .

Creo que su mentor que usa la frase "siempre que tenga sentido" puede ser perjudicial, especialmente para las personas nuevas en TDD, porque no es posible que uno tome una buena decisión al respecto hasta después de tener muchos años de experiencia, después de que uno haya llegado. Ri-level . En una ocasión en la que Kent Beck decidió no escribir una prueba , fue comentado apropiadamente por Ron Jeffries: "Confío en usted y en otras tres personas para tomar buenas decisiones sobre juegos cortos".

Siempre debes escribir una prueba primero. Cualquier cosa que pueda romperse requiere una prueba. Solo las cosas que nunca podrían romperse, debido a que alguien cambió el código, no necesitan pruebas. Por ejemplo, el código declarativo rara vez se rompe: el código de diseño HTML estático en una página web generalmente no vale la pena probar automáticamente (debe probarlo manualmente para ver si se ve bien), pero vale la pena probar todo lo dinámico.

Recientemente, mi mentor en el trabajo me introdujo en el enfoque del desarrollo basado en pruebas, y él me anima a escribir una prueba unitaria cuando "siempre tiene sentido". Entiendo algunos de los beneficios de tener un conjunto de pruebas de unidad para pruebas de regresión y refractoring, pero me pregunto con qué frecuencia y cómo debemos escribir pruebas de unidad.

Mi mentor / líder de desarrollo me pide que escriba un nuevo caso de prueba de unidad para un flujo de control recién escrito en un método que ya está siendo probado por la clase de prueba existente, y creo que es un exceso. ¿Con qué frecuencia escribe las pruebas unitarias y con qué detalle cree que deberían ser las pruebas unitarias? ¡Gracias!

Como dijo Justin, debes escribir tu prueba de unidad antes de escribir el código.

Si bien esto es probablemente lo mejor que se puede hacer, a veces es una exageración. Dependiendo del proyecto, a veces escribo una prueba de unidad solo para cada error que encuentro (y resuelvo).

Claro, probablemente echo de menos algunos de ellos, pero mi prueba de unidad se vuelve más y más eficiente con el tiempo y estoy bastante seguro de que nunca me perderé un error corregido.

Debe escribir una prueba de unidad cada vez que escriba un código. Y, como han señalado otros, en TDD, escribe las pruebas antes de escribir el código.

Si crees que es una exageración, pregúntate "si no pruebo este código, ¿cómo sé que funciona?"

Escribir exámenes y, lo que es más importante, el código comprobable es una habilidad independiente, al igual que aprender a programar cada nuevo idioma es una habilidad independiente.

Lea el blog de Miško Hevery , lea algunos libros (Me gustó Test Driven by Lasse Koskela), use algunas herramientas de cobertura de códigos como Clover y luego escriba algunas pruebas.

A medida que escribas las pruebas, tus habilidades de prueba mejorarán y llegarás a comprender lo que implica escribir un código comprobable. Entonces podrá conocer para su proyecto particular el nivel de cobertura de código que se requiere.

Hay algo fundamental acerca de las pruebas unitarias cuando se realiza un desarrollo guiado por pruebas, a saber, que las pruebas unitarias describen la funcionalidad . Si la prueba no define, por ejemplo, cómo se comportan las entradas nulas, entonces no puede esperar que funcione.

La respuesta correcta / completa para esta pregunta debe ser larga, ya que es una pregunta clave para cada proceso de prueba, pero responderé con las siguientes reglas simples (?):

Si algún caso de uso es importante, escriba una prueba separada para que otra persona (o usted en el futuro) pueda detectar ese caso leyendo o reprobando las pruebas.
Si se está preguntando durante más de 5 segundos si algo es lo suficientemente importante como para probar o no, suponga que es :-)
Si, por casualidad, probar este caso es muy difícil / costoso, se debe presentar una queja al gerente / técnico y omitir la escritura de la prueba.

Las pruebas unitarias deberían darle confianza, que el código que escribe hace lo que quiere. Por lo tanto, debe escribir tantas pruebas como sea necesario para darle esta confianza.

Las pruebas unitarias serán:

le da la confianza para hacer cambios de refactorización mientras sabe que no está rompiendo nada más.
actúa como una especie de "documentación viva" de tu código, permitiendo a otros saber exactamente cómo se comportará el código en diversas circunstancias.
al seguir un TDD estricto como lo describe @Justin , pasar todas las pruebas de unidad escritas antes de comenzar a escribir el código le permitirá saber cuándo está "terminado" la codificación. En mi experiencia, esto también conduce a un código mucho más simplificado y más fácil de entender (más limpio).

Como lo menciona su mentor, solo debe escribir pruebas de unidad que tengan sentido. La regla de oro que uso es que trato de escribir pruebas unitarias para piezas de código que ejecutan la lógica de negocios. Generalmente no escribo pruebas unitarias para clases de bean con poco más que getters y setters.

Las pruebas unitarias usualmente se vuelven más valiosas con el tiempo a medida que se expanden y mejoran para lidiar con las correcciones de errores y otras mejoras de código realizadas después de la entrega inicial.

Personalmente utilizo pruebas unitarias, cuando tengo datos masivos y no quiero copiar / pegar mucho System.out.println, y verificarlos uno a uno. Con las pruebas unitarias, pierdes 1 hora para escribirlas y ahorras muchas de ellas. Para cosas triviales, prefiero usar la técnica de impresión o verificar las variables de depuración.

Siempre debe escribir la prueba, si su versión de prueba existente es insuficiente. La mejor señal, que tus pruebas no son suficientes son errores. Por lo tanto, una buena práctica es escribir una prueba de unidad para cada error que encuentre. Con el desarrollo basado en pruebas, debe comenzar con algunas pruebas, defina la funcionalidad de una clase. herramientas de cobertura de prueba le da algunos consejos, qué partes podrían necesitar más pruebas.

Técnicamente, si está siguiendo un estricto desarrollo guiado por pruebas ... debe escribir sus Pruebas unitarias después de haber especificado alguna parte de su aplicación. Deberías ir de:

Requisitos del usuario -> Diseño de funciones -> Pruebas unitarias -> Código

Recuerda, las pruebas vienen antes del Código en TDD .

Yo también me he convertido recientemente en un converso a TDD y lo encuentro extremadamente útil. La idea es tal que tan pronto como tenga una especificación, comience a escribir pruebas unitarias. Una vez que sus exámenes han sido escritos, una gran mayoría de su código puede provenir de esos exámenes. Lo que queda en sus pruebas son la base de sus afirmaciones y, a continuación, tiene un patrón repetible muy bueno para: escriba la prueba, implemente el código, confirme a través de las afirmaciones, continúe. ¡Buen material!