¿Necesito probar todo?

Voy a comenzar mi primer proyecto real en Ruby on Rails , y me estoy obligando a escribir pruebas TDD . No veo ventajas reales en escribir pruebas, pero como parece muy importante, lo intentaré.

¿Es necesario probar cada parte de mi aplicación, incluidas las páginas estáticas?

TDD no se trata de pruebas, se trata de diseño. Escribir las pruebas te obliga a pensar cómo se supone que funciona la clase y qué tipo de interfaz necesitas. Las pruebas son un efecto secundario feliz que facilita la refactorización posterior.

Entonces, con eso en mente, ¿cuál es el comportamiento de una página estática y cuál es la interfaz?

Mi primera respuesta sería "ninguno" y "ninguno".

Siempre es un análisis de costo-beneficio. ¿Cuál es el costo de la función para usted? Si el costo es alto, pruebe bien y a fondo. Si el costo es bajo, pruebe a la ligera o no lo haga.

También hay que considerar el costo del tiempo de comercialización. Tal vez sea mejor para usted ofrecer una función que funcione en su mayor parte que llegar tarde a una función completamente funcional.

Es casi imposible responder estas preguntas en la OMI general.

Creo que es más importante preservar la capacidad de prueba en el caso de que alguna característica resulte ser más importante de lo que originalmente creías.

Yo diría que sí". Si tiene pruebas que cubren incluso las características y el código más simples, puede estar seguro de que agregar un nuevo código no hace que el código en el lugar deje de funcionar. Del mismo modo, poner a prueba cada error que encuentre evita que las regresiones sigan apareciendo.

Sí, deberías probar todo ...

No necesariamente podrá escribir pruebas automatizadas para todo. Para sus páginas estáticas, considere el uso de Selenium http://seleniumhq.org/ para asegurarse de que las cosas estén correctas.

Desde mi experiencia, algunas cosas de front-end son casi imposibles de escribir para casos de prueba, pero es por eso que realmente querría probar usando el globo ocular Mark 1.

Las pruebas son tan importantes como la codificación. Debe escuchar el dicho "Si algo puede salir mal, lo hará". INMO, de las muchas técnicas de ingeniería de software que se emplean para mejorar la calidad, Testing es la más valiosa para ayudarlo a encontrar problemas temprano.

Si bien probar todo no es posible (especialmente con equipos pequeños y sistemas grandes), no significa que omita las pruebas por completo. ¿Vale la pena la prueba? Consulte la sección "Búsqueda temprana de fallas" en Ver Wiki-SoftwareTesting .

Las pruebas TDD también pueden ser especificaciones vivas si se escriben de esa manera. Los nombres de los métodos de prueba deben tener sentido para un usuario comercial.

Como otros han mencionado, en las pruebas de Ruby on Rails es mucho más importante que en (la mayoría) de otros idiomas. Esto se debe a la falta de un compilador.

Los lenguajes como Delphi , C ++, VB.NET , etc. son lenguajes compilados, y su compilador recogerá muchos errores como errores tipográficos en las llamadas a un método. En Ruby on Rails solo sabrá si hay un error tipográfico o un error en su código si se ejecuta esa línea de código en particular o si está utilizando un IDE que muestra advertencias visuales.

Como CADA línea de código es importante (de lo contrario no estaría allí), debe probar cada método que escriba. Esto es mucho más simple de lo que parece si sigues algunas herramientas básicas de TBDD.

Descubrí que los Rails Cast on Test de Ryan Bates fueron invaluables para mí y realmente resaltaron la simplicidad de TBDD si se realiza correctamente.

Si realmente está utilizando la metodología TDD, entonces no escribe código sin tener primero una prueba unitaria que está tratando de aprobar.

Yo diría que no comience con TDD. Tome una decisión informada cuando haya pasado más tiempo aprendiendo estrategias de arquitectura en general. TDD no le permitirá omitir esa tarea, aunque puede comenzar a creer que sí.

Aquí está mi problema con eso. Cuando dices que parece una gran cantidad de tiempo perdido en cosas que nunca romperán, los TDDers dicen que lo apreciarás cuando esa cosa que no anticipaste en una gran cadena de dependencias se rompa. Cuando señala que es imposible predecir tales cosas antes de escribir su aplicación, que es uh ... por qué probamos, le dicen que realmente se trata más del diseño y no de las pruebas, aunque las pruebas son útiles.

¿Pero no son las cadenas gigantes de dependencias vinculadas impredecibles el producto del diseño horrible?

Entonces, ¿cuál es?

Aquí hay un pensamiento. No tengamos enormes cadenas complejas de dependencias en primer lugar al considerar los siguientes dos principios de diseño orientado a objetos de Design Patterns:

"Programa para una interfaz, no una implementación"

Es decir, a tus objetos no debería importarles quién llama o cómo se hicieron. Solo que los argumentos apropiados se introdujeron y que los métodos que llaman desde otros objetos están dirigidos a funcionar como se esperaba. Su cadena de dependencia en la mayoría de los casos debe estar en un punto de enlace, la llamada al método por parte de la persona que llama y el lugar donde los argumentos se dejan caer en sus métodos. Ahí es donde se registra, valida y envía mensajes útiles para la depuración cuando las cosas se resuelven.

Y:

"Favorecer la composición de objetos sobre la herencia de clases"

¿Quién es el muñeco? ¿El tipo que le hizo algo a una clase en un intrincado esquema de herencia en cascada que involucra como 30 clases que resultan en la ruptura del caso marginal, o el desarrollador que ideó esa arquitectura en primer lugar? TDD podría ayudarlo a llegar al fondo de los problemas dentro de esa torre inclinada de clase Pisa antes de lo que podría haberlo hecho, pero ¿eso hace que sea menos doloroso intentar modificar uno de los puntos finales de ese desastre de código la próxima vez?

Y ahí es donde llego a lo que me molesta. ¿TDD realmente ayuda a diseñar o permite una mala arquitectura? Me parece que tiene potencial para ser una estrategia autocumplida. Cuanto más no tenga su propio equipo la responsabilidad de una arquitectura pobre, más útiles serán esos componentes de prueba granulares, pero en última instancia, su aplicación se convertirá en una PITA cada vez más grande para trabajar (suponiendo que nunca pensaron mucho en la arquitectura al principio lugar). Y no reconocer las consecuencias de eso es, sin duda, el error más costoso que puede cometer al trabajar en una aplicación que debe actualizarse y modificarse con el tiempo.

Para responder la pregunta, piense en "qué podría salir mal aquí". En particular, si cambia el "código" (marcado / lo que sea), ¿cómo va a confiar en que no ha roto la página? Bueno, para una página estática:

• puede que no se procese
• podría presentar incorrectamente
• el JS podría no cargar
• los caminos para las imágenes pueden no funcionar
• los enlaces pueden estar rotos

Personalmente, recomendaría:

• escriba una prueba de selenio [1] que verifique la cadena que espera en la página (cerca de la parte inferior si es posible). Esto valida que se procesa.
• compruebe que no hay errores de JS (creo que el selenio lo permite)
• ejecute las páginas estáticas a través de un validador html y, si es posible, un verificador de enlaces.
• No he encontrado una herramienta que me guste para validar JS, pero es posible que tenga éxito con jslint o jshint.

La conclusión aquí es que desea algo que sea repetible, fácil de usar y que se ejecute automáticamente en su corredor de prueba.

Solo para agregar a todas las respuestas ya excelentes, aquí está mi pensamiento sobre qué evaluar y qué no evaluar:

Hacer prueba:

• lógica de negocios
• lógica de aplicación
• funcionalidad
• comportamiento,
• entonces, todo, realmente, excepto :

No probar:

• constantes
• presentación

Entonces no tiene sentido hacerse una prueba que diga:

assert wibble = 3

y un código que dice

wibble = 3

Y tampoco tiene sentido probar cosas de presentación, como si el ícono está en azul perywinkle, qué fuente ha utilizado para los encabezados, etc.

Entonces, pregunta, "debería probar páginas estáticas", y la respuesta es: las prueba en la medida en que son parte de la funcionalidad, la lógica comercial o el comportamiento de su sitio.

Entonces, en nuestra aplicación, tenemos una prueba que verifica que los términos y condiciones estén disponibles en todas las partes del sitio, para usuarios anónimos, para usuarios que han iniciado sesión, desde el tablero, dentro de las pantallas de la aplicación, etc. Simplemente verifica que haya un enlace llamado "términos y condiciones" en cada página, que el enlace funciona, y luego la prueba dice que cuando llega a la página, "parece" los Ts & Cs, lo suficiente para asegurarse de que es la página correcta, sin "probar una constante" o "probar la presentación" ... para que pueda verificar que el texto sea correcto, por ejemplo, sin verificar el tamaño de fuente o el diseño de texto en particular ...