unit testing - que - ¿Cómo comenzar la prueba unitaria o TDD?

tdd ejemplo (14)

Leí un montón de publicaciones que me convencieron de que debería comenzar a escribir pruebas unitarias, también comencé a usar la inyección de dependencia (Unidad) por una burla más fácil, pero aún no estoy seguro de en qué etapa debo comenzar a escribir la unidad. pruebas y burlas, y cómo o dónde comenzar.

¿Sería preferible escribir las pruebas unitarias antes que los métodos descritos en la metodología TDD?

¿Hay alguna metodología o manera diferente para las pruebas unitarias?

Ampliando la respuesta de Steve Freeman: el libro de Dave Astel se llama "Desarrollo basado en pruebas: una guía práctica". Si el tipo de aplicación que está escribiendo es una aplicación GUI, esto debería ser útil. Leí el libro de Kent Becks, pero no pude entender cómo comenzar un proyecto con TDD. El libro de Astel prueba una aplicación GUI no trivial completa de principio a fin usando historias. Me ayudó muchísimo comenzar con TDD, me mostró dónde y cómo comenzar.

Creo que el libro de Dave Astels sigue siendo una de las mejores presentaciones. Es para Java, pero debería poder traducir.

Elija una aplicación pequeña no crítica e impleméntela usando TDD. Al principio, la nueva forma de pensar se sentirá rara, pero tal vez después de una semana o dos de práctica se sienta natural.

Aquí hay una aplicación de tutorial (en la rama "tutorial") que muestra qué tipos de pruebas escribir. En ese tutorial, usted escribe el código para pasar los casos de prueba predefinidos, de modo que ingrese al ritmo, y luego usted escribe sus propias pruebas. El archivo README contiene instrucciones. Está escrito en Java, pero puedes adaptarlo fácilmente a C #.

En C # y con Visual Studio encuentro el siguiente procedimiento muy útil:

¡Pensar! Haga un pequeño diseño inicial. Necesita tener una idea clara de las clases que necesita y cómo los objetos deberían relacionarse entre sí. Concéntrate solo en una clase / objeto (la clase / objeto que deseas implementar) y una relación. De lo contrario, terminas con un diseño demasiado pesado. A menudo termino con varios bocetos (solo unos pocos cuadros y flechas) en una hoja de papel extra.
Cree la clase en el código de producción y asígnele un nombre apropiado.
Elija un comportamiento de la clase que desea implementar y cree un trozo de método para él. Con visual studio crear stubs de métodos vacíos es pan comido.
Escribe una prueba para eso. Por lo tanto, deberá inicializar ese objeto, llamar al método y hacer una afirmación para verificar el resultado. En el caso más sencillo, la afirmación requiere otro stub de método o una propiedad en el código de producción.
¡Compila y deja que el corredor de prueba te muestre la barra roja!
Codifique el comportamiento requerido en el código de producción para ver aparecer la barra verde.
Pase al siguiente comportamiento.

Para este procedimiento, dos cosas son muy importantes:

Necesita una imagen clara de lo que quiere y de cómo debe ser la clase / objeto. Al menos, dedícale un tiempo.
Piensa en los comportamientos de la clase / objeto. Esto hará que las pruebas y el código de producción se centren en el comportamiento, lo cual es un enfoque muy natural para pensar en clases / objetos.

Prueba primero o no prueba primero?

En general, me resulta más difícil adaptar las pruebas al código de producción existente. En la mayoría de los casos esto se debe a dependencias enredadas con otros objetos, cuando el objeto que se está probando debe inicializarse. Por lo general, TDD evita esto, porque desea inicializar el objeto en los casos de prueba con el menor esfuerzo posible. Esto dará como resultado un acoplamiento muy flojo.

Cuando realizo las pruebas de actualización, el trabajo engorroso que debe realizar es la tarea de inicializar el objeto bajo prueba. También las afirmaciones pueden ser un montón de trabajo debido a las dependencias enredadas. Para esto, necesitará cambiar el código de producción y romper las dependencias. Al usar la inyección de dependencia correctamente, esto no debería ser un problema.

He trabajado para empresas que realizan pruebas unitarias de pruebas / integración demasiado lejos y aquellas que hacen muy poco, así que me gusta pensar que tengo un buen equilibrio entre las dos.

Recomendaría TDD - Desarrollo impulsado por prueba. Esto garantiza que tenga una buena cobertura, pero también sigue centrando su atención en el lugar y el problema correctos.

Entonces, lo primero que debe hacer para cada nuevo desarrollo es escribir una prueba unitaria, incluso si no tiene una sola clase para evaluar.

Piensa en lo que estás probando. Ahora ejecuta la prueba. ¿Por qué no compilaría? Porque necesitas clase A. Crea la clase y ejecuta la prueba. ¿Por qué no compila? Porque no tiene methodA. Escriba el método uno y ejecute la prueba unitaria nuevamente. ¿Por qué falla la prueba? Porque el método A no está implementado. Implemente el método A y ejecute la prueba. ¿Por qué falla? Porque el método A no devuelve el valor esperado correcto ... etc.

Continúas así a medida que desarrollas pruebas de la unidad de escritura y, finalmente, la prueba pasará y la pieza de funcionalidad estará completa.

Lea la Prueba de unidad pragmática en C # con NUnit . Tiene información completa sobre cómo comenzar a redactar testículos y cómo estructurar el código para que sea más fácil para las pruebas de unidades.

Prefiero el enfoque de KentBeck, que está muy bien explicado en el libro Test Driven Development by Example - Kent Beck.

de su pregunta, puedo inferir que no está seguro con el trabajo del marco de prueba: elegir el marco de prueba correcto es muy importante para las pruebas de unidad de escritura o TDD (en general).

El único problema práctico con TDD es "Refactorizar" (también necesitamos refactorizar el código de prueba) que lleva mucho tiempo.

Sí, la forma preferida de hacer TDD es escribir primero la prueba (como lo sugiere el nombre Test-Driven Development ). Cuando comienzas con TDD, puede ser difícil saber por dónde empezar a escribir las pruebas, por lo que sugiero que seas pragmático al respecto. Después de todo, la parte más importante de nuestro trabajo es entregar código de trabajo, no tanto cómo se diseñó el código.

Entonces puede comenzar escribiendo pruebas para el código existente. Una vez que entienda cómo están estructuradas las pruebas unitarias, cuáles parecen hacer un buen trabajo y cuáles no son tan buenas, entonces le resultará más fácil profundizar más en el enfoque de probar primero. Descubrí que primero escribo pruebas en mayor medida con el paso del tiempo. Simplemente se vuelve más natural con una mayor experiencia.

Si no ha escrito pruebas unitarias antes, simplemente elija algunas clases y comience a escribir sus pruebas unitarias, y continúe trabajando en el desarrollo de más pruebas unitarias.

A medida que adquiere experiencia, puede empezar a burlarse de la base de datos, por ejemplo, utilizando el marco Unity, pero, le sugiero que comience simplemente y gane experiencia antes de dar este salto.

Una vez que se sienta cómodo con la forma de escribir pruebas unitarias, puede intentar hacer TDD.

Si tiene curiosidad acerca de las pruebas unitarias, la mejor forma de aprender es intentarlo. Probablemente comiences a escribir pruebas de integración al principio, pero está bien. Cuando parezcan demasiado difíciles de mantener o demasiado trabajo para escribir, lea más sobre qué tipo de pruebas hay (unidad, funcional, integración) e intente aprender la diferencia.

Si estás interesado en comenzar con TDD, el tío Bob es una buena fuente. Particularmente this .

Más sobre pruebas unitarias

Asegúrese de obtener resultados de prueba consistentes. Ejecutar la misma prueba repetidamente debe devolver los mismos resultados consistentemente.

Las pruebas no deben requerir configuración.

El orden de prueba no debería importar Esto significa que las ejecuciones de prueba parciales pueden funcionar correctamente. Además, si tiene en cuenta esta filosofía de diseño, es probable que le ayude en la creación de su prueba.

Recuerde que cualquier prueba es mejor que ninguna prueba. La dificultad se puede encontrar al escribir buenas pruebas de unidades limpias que promueven la facilidad de creación y mantenimiento. Cuanto más difícil sea el marco de prueba, más oposición habrá para emplearlo. La prueba es tu amiga

Steve Sanderson tiene una excelente reseña sobre las mejores prácticas de TDD.

http://feeds.codeville.net/~r/SteveCodeville/~3/DWmOM3O0M2s/

Además, hay un gran conjunto de tutoriales para hacer un proyecto ASP.NET mvc que discute muchos principios TDD (si no te importa aprender ASP.net MVC en el camino) http://www.asp.net/learn/mvc-videos/ Busque la serie "Escaparate" en la parte inferior de la página.

MOQ parece ser el marco de burla caliente últimamente, es posible que desee examinar eso también

En resumen, intente escribir una prueba para validar algo que intenta archivar, luego implemente el código para que funcione.

El patrón se conoce como Rojo - Verde - Refactor. También haz tu mejor esfuerzo para minimizar las dependencias para que tus pruebas se puedan enfocar en un componente.

Personalmente, utilizo las Pruebas unitarias de Visual Studio. No soy un desarrollador de TDD hardcore, pero lo que me gusta hacer es esto:

Cree un nuevo proyecto y defina algunas de las clases fundamentales basadas en el diseño del sistema (de esa forma al menos puedo obtener algo de intellisense)
crea un proyecto de pruebas unitarias y comienza a escribir pruebas unitarias para satisfacer la funcionalidad que intento implementar.
Hazlos fallar
Hazlos pasar (implementar)
Refactor
Repita, intente hacer la prueba más estricta o cree más pruebas hasta que sienta que es sólida.

También me parece muy útil agregar funcionalidad a una base de código que sale. Si desea agregar alguna característica nueva, primero cree la prueba de la unidad para lo que desea agregar, recorra el código para ver lo que tiene que cambiar, luego realice el proceso de TDD.

Tomaría TDD, desarrollo de prueba primero, antes de simulacros e inyección de dependencia. Para estar seguro, los simulacros pueden ayudarlo a aislar mejor sus unidades y, por lo tanto, a realizar mejores pruebas de unidades , pero en mi opinión, burlarse y DI son conceptos más avanzados que pueden interferir con la claridad de simplemente escribir sus pruebas primero.

Mocks y DI tienen su lugar; son buenas herramientas para tener en tu caja de herramientas. Pero toman un poco de sofisticación, una comprensión más avanzada, que la típica prueba de neófito. Escribir sus pruebas primero, sin embargo, es exactamente tan simple como suena. Por lo tanto, es más fácil de asumir, y es poderoso por sí mismo (sin simulacros ni DI). Obtendrá ganancias más rápidas y más fáciles al escribir pruebas simuladas primero, que al tratar de comenzar con burlas, y TDD, y DI a la vez.

Comience con la prueba primero; cuando te sientas muy cómodo con él, y cuando tu código te indique que necesitas burlarse, entonces hazte burlas.

Prueba primero / prueba después:

Cabe señalar que "probar primero" como parte de TDD es tanto (si no más) relacionado con el diseño como lo es con las pruebas unitarias. Es una técnica de desarrollo de software en sí misma: escribir los resultados de las pruebas en un refinamiento constante del diseño.

En una nota aparte: si hay una ventaja significativa para TDD desde una perspectiva de pruebas unitarias puras, es que es mucho más difícil (aunque no imposible) escribir una prueba que está mal al hacer TDD. Si escribe la prueba de antemano, siempre debería fallar porque aún no existe la lógica necesaria para hacer que pase la prueba. Si luego escribe la prueba, la lógica debería estar allí, pero si la prueba tiene errores o está probando algo incorrecto, puede pasar de todos modos.

Es decir, si hace una mala prueba antes, puede obtener una luz verde cuando espera una luz roja (para que sepa que la prueba es mala). Si luego escribe una mala prueba, obtendrá luz verde cuando espere un color verde (sin darse cuenta de la mala prueba).

Libros

Vale la pena echarle un vistazo al libro de pruebas pragmáticas de la unidad, al igual que Roy Osherove, "The Art of Unit Testing". El libro pragmático se enfoca más estrictamente en los diferentes tipos de entradas de prueba, puede tratar de encontrar errores, mientras que TAOUT cubre una amplia gama de temas como dobles de prueba, estrategias, mantenibilidad, etc. Cualquiera de los dos libros es bueno; depende de lo que quieras de él.

Además, aquí hay un enlace a una charla que Roy Osherove hizo sobre pruebas unitarias . Merece la pena verlo (también lo son algunos de los videos de revisión de prueba que registró, ya que señala varios problemas y qué hacer / no hacer, junto con las razones por las cuales).

Cómo empezar

No hay nada mejor que escribir código. Encuentra una clase bastante simple que no haga referencia a mucho más. Luego, comienza a escribir algunas pruebas.

Siempre pregúntese "¿qué quiero probar y probar con esta prueba?" antes de escribirlo, entonces déle un nombre decente (generalmente involucrando el método que se llama, el escenario y el resultado esperado, por ejemplo, en una pila: "Pop WhenStackIsEmpty ThrowsException").

Piense en todas las entradas que puede arrojar, diferentes combinaciones de métodos que pueden arrojar resultados interesantes, etc.

El desarrollo impulsado por pruebas puede ser confuso para principiantes, muchos libros que leí cuando estaba aprendiendo TDD le enseñarían cómo escribir pruebas unitarias para una clase de calculadora, pero parece que hay muy poca ayuda para construir aplicaciones del mundo real, que son más datos centrados si me atrevo a decir. Para mí, el gran avance fue cuando comprendí qué es el Desarrollo Dirigido por Comportamiento o BDD y cómo comenzar a hacer las pruebas desde afuera. Ahora, simplemente puedo aconsejarle que se concentre en el comportamiento de su aplicación y que escriba pruebas unitarias para verificarlo. Hay mucho debate entre TDD y BDD, pero creo que las pruebas automáticas bien redactadas en todos los niveles agregan valor y para escribirlas debemos centrarnos en el comportamiento.

Hadi Hariri tiene una excelente publicación aquí http://hadihariri.com/2012/04/11/what-bdd-has-taught-me/

También he escrito algunos artículos sobre el tema que creo que ayudarán a comprender todos los conceptos relacionados con TDD aquí.

http://codecooked.com/introduction-to-unit-testing-and-test-driven-development/

http://codecooked.com/different-types-of-tests-and-which-ones-to-use/