unit-testing - what - unit testing tools
¿Escribir código de "unidad comprobable"? (19)
- Usa TDD
- Al escribir tu código, utiliza la inyección de dependencia siempre que sea posible
- Programe las interfaces, no las clases concretas, para que pueda sustituir las implementaciones simuladas.
¿Qué tipo de prácticas usas para que tu código sea más amigable con las pruebas de unidades?
Al escribir pruebas (como con cualquier otra tarea de software) No repetir (principio DRY). Si tiene datos de prueba que son útiles para más de una prueba, colóquela en un lugar donde ambas pruebas puedan usarla. No copie el código en ambas pruebas. Sé que esto parece obvio, pero veo que sucede todo el tiempo.
Asegúrese de que todas sus clases sigan el Principio de Responsabilidad Individual . La responsabilidad única significa que cada clase debe tener una y única responsabilidad. Eso hace que las pruebas unitarias sean mucho más fáciles.
Comprueba esta charla Patrones de prueba automatizados y olores . Una de las cosas más importantes para mí fue asegurarme de que el código UnitTest sea de alta calidad. Si el código está bien documentado y bien escrito, todos estarán motivados para seguir así.
Dedique algo de tiempo a refaccionar el código no comprobable para que sea comprobable. Escriba las pruebas y obtenga una cobertura del 95%. Hacer eso me enseñó todo lo que necesito saber sobre cómo escribir un código comprobable. No me opongo a TDD, pero aprender los detalles de lo que hace que el código sea comprobable o no comprobable te ayuda a pensar en la capacidad de prueba en el momento del diseño.
Estoy seguro de que voy a estar abajo votaron por esto, pero voy a expresar la opinión de todos modos :)
Si bien muchas de las sugerencias aquí han sido buenas, creo que es necesario moderarlas un poco. El objetivo es escribir software más sólido que sea modificable y mantenible.
El objetivo no es tener un código que sea comprobable por unidad. Se hace un gran esfuerzo para que el código sea más "comprobable" a pesar de que el código comprobable no es el objetivo. Suena muy bien y estoy seguro de que le da a la gente una buena dosis de calor, pero la verdad es que todas esas técnicas, marcos, pruebas, etc., tienen un costo.
Cuestan tiempo en capacitación, mantenimiento, sobrecarga de productividad, etc. A veces vale la pena, a veces no, pero nunca se debe poner las anteojeras y cargar antes para hacer que su código sea más "comprobable".
Intento continuamente encontrar un proceso donde las pruebas unitarias sean menos exigentes y algo que realmente quiera hacer. En mi experiencia, un factor bastante importante son tus herramientas. Hago mucho trabajo de ActionScript y, lamentablemente, las herramientas son algo limitadas, como la integración sin IDE y la falta de marcos de burla más avanzados (pero las cosas buenas están por venir, así que no tengo quejas aquí). He hecho un desarrollo impulsado por pruebas antes con marcos de prueba más maduros y definitivamente fue una experiencia más placentera, pero aún así me sentí como un trabajo pesado.
Recientemente empecé a escribir código de una manera diferente. Solía empezar a escribir la prueba, ver cómo fallaban, escribir código para que la prueba tuviera éxito, enjuagar y repetir y todo eso.
Ahora, sin embargo, empiezo escribiendo interfaces, casi sin importar lo que vaya a hacer. Al principio, por supuesto trato de identificar el problema y pensar en una solución. Luego empiezo a escribir las interfaces para obtener una especie de sensación abstracta para el código y la comunicación. En ese momento, normalmente me doy cuenta de que realmente no he encontrado una solución adecuada para el problema en absoluto como resultado de que no entiendo completamente el problema. Así que vuelvo, reviso la solución y reviso mis interfaces. Cuando siento que las interfaces reflejan mi solución, en realidad empiezo escribiendo la implementación, no las pruebas. Cuando tengo algo implementado (borrador implementado, generalmente pasos de bebé), comienzo a probarlo. Sigo retrocediendo entre probar e implementar, unos pocos pasos adelante a la vez. Como tengo interfaces para todo, es increíblemente fácil de inyectar.
Me parece que trabajar así, con clases que tienen muy poco conocimiento de otras implementaciones y que solo hablan con interfaces, es extremadamente liberador. Me libera de pensar en la implementación de otra clase y puedo enfocarme en la unidad actual. Todo lo que necesito saber es el contrato que proporciona la interfaz.
Pero sí, todavía estoy tratando de resolver un proceso que funciona súper-fantásticamente-asombrosamente-bien cada vez.
Ah, también quería agregar que no escribo pruebas para todo. Las propiedades de vainilla que no hacen mucho más que obtener / establecer variables son inútiles para probar. Ellos están engañados por el contrato de lenguaje para trabajar. Si no lo hacen, tengo problemas mucho peores que mis unidades no se pueden probar.
La forma más fácil es no verificar su código a menos que verifique las pruebas con él.
No soy un gran fan de escribir las pruebas primero. Pero una cosa en la que creo firmemente es que el código debe verificarse con pruebas. Ni siquiera una hora más o menos antes, juntos . Creo que el orden en que se escriben es menos importante siempre que entren juntos.
La inyección de dependencia parece ayudar.
Métodos pequeños y altamente cohesivos. Lo aprendo de la manera difícil. Imagine que tiene un método público que maneja la autenticación. Tal vez hiciste TDD, pero si el método es grande, será difícil depurarlo. En cambio, si ese método #authenticate hace las cosas de una forma más pseudocodish, llamando a otros métodos pequeños (quizás protegidos), cuando aparece un error, es fácil escribir nuevas pruebas para esos pequeños métodos y encontrar el defectuoso.
No Estática: no puedes burlarte de la estática.
Además, google tiene una herramienta que medirá la capacidad de prueba de tu código ...
Primero escriba las pruebas, de esa manera, las pruebas dirigen su diseño.
Utilizo desarrollo controlado por pruebas siempre que sea posible, por lo que no tengo ningún código que no pueda probarse en una unidad. No existiría a menos que existiera la prueba unitaria primero.
Y algo de lo que aprendes lo primero en OOP, pero muchos parecen olvidar: Código contra Interfaces, No Implementaciones .
Para preparar su código para que se pueda probar:
- Documente sus suposiciones y exclusiones.
- Evite las clases complejas grandes que hacen más de una cosa: tenga en mente el principio de responsabilidad única .
- Cuando sea posible, use interfaces para desacoplar interacciones y permita inyectar objetos falsos.
- Cuando sea posible, haga que el método púbico sea virtual para permitir que los objetos falsos los emulen.
- Cuando sea posible, use la composición en lugar de la herencia en sus diseños; esto también fomenta (y respalda) la encapsulación de comportamientos en las interfaces.
- Cuando sea posible, use bibliotecas de inyección de dependencia (o prácticas de DI) para proporcionar instancias con sus dependencias externas.
Para aprovechar al máximo las pruebas de su unidad, tenga en cuenta lo siguiente:
- Infórmese usted y su equipo de desarrollo sobre las capacidades del marco de pruebas de unidades, las bibliotecas de burlas y las herramientas de prueba que pretende utilizar. Entender lo que pueden y no pueden hacer será esencial cuando comiences a escribir tus pruebas.
- Planifique sus pruebas antes de comenzar a escribirlas. Identifique los casos extremos, las restricciones, las condiciones previas, las postcondiciones y las exclusiones que desee incluir en sus pruebas.
- Arregle las pruebas rotas tan cerca como cuando las descubra como sea posible. Las pruebas lo ayudan a descubrir defectos y posibles problemas en su código. Si sus pruebas están rotas, abre la puerta a tener que arreglar más cosas más tarde.
- Si sigue un proceso de revisión de código en su equipo, revise también las pruebas de su unidad. Las pruebas unitarias son una parte tan importante de su sistema como cualquier otro código: las revisiones ayudan a identificar las debilidades en las pruebas de la misma manera que lo harían con el código del sistema.
1.Using a framework/pattern like MVC to separate your UI from you
business logic will help a lot.
2. Use dependency injection so you can create mock test objects.
3. Use interfaces.
TDD: primero escribe las pruebas, te obliga a pensar en la capacidad de prueba y te ayuda a escribir el código que realmente se necesita, no lo que crees que puedas necesitar
Refactorizar a las interfaces: hace más fácil la burla
Los métodos públicos virtuales, si no usan interfaces, hacen más fácil la burla
Inyección de dependencia: facilita la burla
Métodos más pequeños y más específicos: las pruebas están más centradas, son más fáciles de escribir
Evitar clases estáticas
Evite los singletons, excepto cuando sea necesario
Evita las clases selladas