unit-testing - tipos - pruebas unitarias php
¿Qué tan lento es demasiado lento para las pruebas unitarias? (6)
¿Cuánto tiempo es demasiado largo para que un desarrollador espere a que se complete el conjunto de pruebas de la unidad? Realmente depende de cuánto tiempo estén felices los desarrolladores de esperar el feedback de su cambio. Diría que si empieza a hablar minutos, es demasiado lento y probablemente debería dividir la serie de pruebas en proyectos de prueba individuales y ejecutarlos por separado.
Michael Feathers, en Trabajar eficazmente con el código heredado , en las páginas 13-14 menciona:
Una prueba de unidad que tarda 1/10 de segundo en ejecutarse es una prueba de unidad lenta ... Si [pruebas de unidad] no se ejecuta rápido, no son pruebas de unidad.
Puedo entender por qué 1/10 por segundo es demasiado lento si uno tiene 30,000 pruebas, ya que tomaría cerca de una hora en ejecutarse. Sin embargo, ¿significa esto que 1/11 de segundo es mejor? No, en realidad no (ya que es solo 5 minutos más rápido). Así que una regla dura y rápida probablemente no sea perfecta.
Por lo tanto, al considerar qué tan lento es demasiado lento para las pruebas de una unidad, tal vez debería reformular la pregunta. ¿Cuánto tiempo es demasiado largo para que un desarrollador espere a que se complete el conjunto de pruebas de la unidad?
Para dar un ejemplo de velocidades de prueba. Echa un vistazo a varios tiempos de la prueba de unidad MSTest:
0.2637638 seconds
0.0589954
0.0272193
0.0209824
0.0199389
0.0088322
0.0033815
0.0028137
0.0027601
0.0008775
0.0008171
0.0007351
0.0007147
0.0005898
0.0004937
0.0004624
0.00045
0.0004397
0.0004385
0.0004376
0.0003329
El promedio de todas las 21 de estas pruebas unitarias es de 0.019785 segundos. Tenga en cuenta que la prueba más lenta se debe a que utiliza Microsoft Moles para simular / aislar el sistema de archivos.
Entonces, con este ejemplo, si mi conjunto de pruebas de unidad crece a 10,000 pruebas, podría demorar más de 3 minutos en ejecutarse.
Entonces, ¿cuál es tu pregunta? :-) Estoy de acuerdo, la verdadera métrica aquí es cuánto tiempo tienen que esperar los desarrolladores para una ejecución completa de las pruebas unitarias. Demasiado tiempo y comenzarán a cortar las esquinas antes de cometer el código. Me gustaría ver una compilación de compromiso completa en menos de un minuto o dos, pero eso no siempre es posible. En mi trabajo, una compilación de compromiso solía tomar 8 minutos y la gente solo comenzaba a ejecutar pequeñas partes antes de comprometerse, así que compramos máquinas más poderosas :-)
He analizado uno de esos proyectos en los que la cantidad de pruebas unitarias hizo que el sistema tomara demasiado tiempo para probar todo. "Demasiado" significa que básicamente no lo hizo como parte de su rutina de desarrollo normal.
Sin embargo, lo que habían hecho fue clasificar las pruebas unitarias en dos partes. Pruebas críticas, y "todo lo demás".
Las pruebas críticas tardaron solo unos segundos en ejecutarse y probaron solo las partes más críticas del sistema, donde "crítico" significa "si algo va mal aquí, todo va a estar mal".
Las pruebas que hicieron que la ejecución completa tomara demasiado tiempo fueron relegadas a la sección "Todo lo demás", y solo se ejecutaron en el servidor de compilación.
Cada vez que alguien enviaba un código al repositorio de control de origen, las pruebas críticas se ejecutaban primero y luego se programaba una "ejecución completa" unos minutos en el futuro. Si nadie registró el código durante ese intervalo, se ejecutaron las pruebas completas. Por supuesto, no tomaron 30 minutos, más como 8-10.
Esto se hizo con TeamCity, por lo que incluso si un agente de compilación estaba ocupado con el traje de prueba de la unidad completa, los otros agentes de compilación aún podían realizar confirmaciones normales y ejecutar las pruebas de unidad críticas con la frecuencia que fuera necesaria.
Primero, vea mi comentario a la respuesta de Zack con respecto a la diferencia entre las pruebas UNIT y las pruebas INTEGRATION.
Luego, use una herramienta como Might-Moose (http://continuoustests.com/) que solo ejecuta las pruebas afectadas por el cambio de código (en lugar de toda su biblioteca de pruebas) cada vez que se registra un archivo. Antes de comenzar a quejarse sobre "cuánto tiempo tomaría", mira los videos en su sitio. Oh, por cierto, es gratis.
Solo he trabajado en proyectos en los que el conjunto de pruebas tardó al menos diez minutos en ejecutarse. Los más grandes, eran más como horas. Lo chupamos y esperamos, porque estaban casi garantizados para encontrar al menos un problema en cualquier cosa que les arrojara. Los proyectos eran tan grandes y peludos.
Quiero saber qué son estos proyectos que pueden probarse exhaustivamente en segundos.
(El secreto para hacer las cosas cuando las pruebas de unidad de su proyecto toman horas es tener cuatro o cinco cosas en las que está trabajando al mismo tiempo. Usted lanza un conjunto de parches en el conjunto de pruebas y su conmutador de tareas, y por Una vez que haya terminado con lo que cambió, tal vez sus resultados hayan regresado.)
Tengo pruebas unitarias que tardan unos segundos en ejecutarse. Tengo un método que hace computación muy complicada y miles de millones y miles de millones de operaciones. Hay algunos valores que sabemos que utilizamos como base para las pruebas unitarias cuando refactorizamos este método complicado y súper rápido (que debemos optimizar al máximo porque, como dije, está realizando miles de millones y miles de millones de cálculos). ).
Las reglas no se adaptan a cada dominio / espacio de problemas.
No podemos "dividir" este método en métodos más pequeños que podamos probar por unidad: es un método pequeño pero muy complicado (haciendo uso de tablas precomputadas increíblemente enormes que no se pueden volver a crear lo suficientemente rápido sobre la marcha, etc.) .
Tenemos pruebas unitarias para ese método. Son pruebas unitarias. Tardan segundos en ejecutarse. Es una cosa buena [TM].
Ahora, por supuesto, no cuestiono que use bibliotecas de pruebas unitarias como JUnit para cosas que no sean pruebas unitarias: por ejemplo, también usamos JUnit para probar escenarios complejos de múltiples subprocesos. Estos no son "prueba de unidad", pero puedes apostar a que JUnit aún gobierna el día :)