Guía del aspecto: Tests
El aspecto de tests responde a una pregunta: ¿hasta qué punto está probado este código? Es una pregunta que, en rigor, solo se contesta ejecutando los tests. Las métricas de este aspecto se reparten en dos grupos muy distintos:
- Métricas estáticas, que se calculan leyendo el código sin ejecutar nada: cuánto código de test hay, cuántas clases y métodos de test, cuántas aserciones y desde dónde se llama a cada método. Son las que calcula Stau Metro.
- Métricas dinámicas, que exigen ejecutar los tests: la «cobertura de código» (qué ejecutan) y la «puntuación de mutación» (qué errores detectarían). Stau Metro no las calcula; tienen página porque son la referencia con la que hay que leer las demás.
Las estáticas dicen cuánto esfuerzo de test hay y dónde está. Las dinámicas dicen qué consigue ese esfuerzo. Confundir unas con otras es el error más frecuente de este aspecto, y tiene su propia sección más abajo.
Para quien empieza. Un test es código que llama a tu código y comprueba el resultado con una aserción (
assertEquals(3, suma(1, 2))). Contar tests y aserciones dice cuántas comprobaciones has escrito. No dice qué partes del programa recorren ni si fallarían ante un error: eso es lo que miden la cobertura y la mutación.
Por dónde empezar
- «Ratio de test» (
TEST_RAT) por módulo y por paquete: qué parte de las líneas es código de test. Es la única métrica del aspecto que el catálogo de Stau Metro marca como esencial. Un módulo con 0 % o muy por debajo de los demás es la primera pista de dónde faltan tests. - «Número de métodos de test JUnit» (
JTM) y «número de aserciones de test JUnit» (JTA), juntas: su cociente es el número medio de aserciones por test. Un promedio cercano a cero señala tests que ejecutan sin comprobar. - «Número de veces invocado en código de test» (
CALLEDt) en los métodos importantes de producción: un 0 dice que ningún test los llama directamente.
Si tienes una herramienta de cobertura, su informe va antes que todo lo anterior: las métricas estáticas sirven sobre todo donde no hay cobertura, o para explicar lo que la cobertura muestra.
Ninguna métrica del aspecto tiene umbrales de referencia en Stau Metro. Los de la cobertura (60, 75 y 90 % en la guía de Google; 80 % en el código nuevo en el quality gate «Sonar way» de SonarQube) son normas de equipos y de herramientas, no resultados de investigación; su página los explica.
Todas las métricas del aspecto
«Mejor si sube» indica la dirección «más alto es mejor»; las demás son informativas: ni alto ni bajo es mejor.
| Métrica | Niveles | Stau Metro | Qué dice | Dirección |
|---|---|---|---|---|
«Líneas de código de test» (LOCt) |
paquete, módulo, proyecto | sí | Líneas no vacías de los ficheros de las raíces de test, de cualquier lenguaje | informativa |
«Líneas sin comentarios (test)» (NCLOCt) |
paquete, módulo, proyecto | sí | Lo mismo sin las líneas que solo son comentario | informativa |
«Ratio de test» (TEST_RAT) |
paquete, módulo, proyecto | sí | Líneas de test entre líneas de test más de producción | mejor si sube |
«Número de clases de test» (Ct) |
paquete, módulo, proyecto | sí | Tipos declarados en ficheros Java de las raíces de test, tengan o no tests | informativa |
«Número de casos de test JUnit» (JTC) |
paquete, módulo, proyecto | sí | Clases con algún método de test, propio o heredado, o que extienden TestCase de JUnit 3 |
informativa |
«Número de métodos de test JUnit» (JTM) |
clase, paquete, módulo, proyecto | sí | Métodos que JUnit 3, 4, 5 o TestNG ejecutarían como tests | informativa |
«Número de aserciones de test JUnit» (JTA) |
clase, paquete, módulo, proyecto | sí | Llamadas a assert… y fail dentro de métodos de test |
informativa |
«Número de veces invocado en código de test» (CALLEDt) |
método | sí | Puntos de llamada al método desde ficheros de test | informativa |
| «Cobertura de código» | método a proyecto | no | Qué parte del código ejecutan los tests: líneas, ramas, condiciones… | mejor si sube |
| «Puntuación de mutación» | método a proyecto | no | Qué parte de los errores sembrados a propósito detectan los tests | mejor si sube |
Las de Stau Metro que se miden en paquete, salvo TEST_RAT, tienen además una variante recursiva que suma los
subpaquetes.
Dos formas de reconocer un test
Para contar «código de test» hay que decidir qué lo es. Stau Metro usa dos criterios, y saber cuál usa cada métrica explica casi todas las sorpresas:
| Criterio | Métricas | Qué entra |
|---|---|---|
Por ubicación: el fichero está en una raíz de fuentes de test del proyecto (src/test/java y similares) |
LOCt, NCLOCt, TEST_RAT, Ct, CALLEDt |
todo lo que haya en esas raíces: clases de apoyo, constructores de datos, mocks escritos a mano |
Por contenido: el método lleva una anotación de test de JUnit 4, JUnit 5 o TestNG, o sigue la convención de JUnit 3; para JTC, la clase tiene algún método así o extiende TestCase |
JTC, JTM, JTA |
lo que parece un test por sus anotaciones o su nombre, esté donde esté, también en código de producción; se aproxima a lo que ejecutaría el framework, pero no coincide del todo (ver «Qué no miden») |
Consecuencias prácticas:
- La diferencia entre
CtyJTCson, sobre todo, las clases de apoyo de los tests. - Los criterios por ubicación dependen de que el proyecto declare bien sus raíces. Si los tests viven en una carpeta
que el IDE trata como producción,
TEST_RATlos cuenta como código de producción yJTMsigue contándolos. LOCt,NCLOCtyTEST_RATcuentan cualquier lenguaje de las raíces de test.Ct,JTC,JTMyJTAsolo ven Java: los tests escritos en Kotlin no aparecen en ellas.- Los ficheros de las raíces de recursos de test (
src/test/resources) no cuentan enLOCt,NCLOCtniTEST_RAT: los datos de los tests no son código de test.
Por qué el tamaño de los tests no es cobertura
TEST_RAT y LOCt miden cuánto código de test hay. La cobertura mide qué código de producción se ejecuta al
pasar los tests. Son cosas distintas, y pueden ir en direcciones opuestas:
- Un test grande puede probar poco. Cien líneas que preparan datos y llaman una y otra vez al mismo método
suman mucho a
LOCty cubren un solo método. - Un test pequeño puede cubrir mucho. Una sola llamada a un punto de entrada ejecuta todo lo que cuelga de él. Las líneas de test son pocas; la cobertura de líneas, alta.
- Ninguna de las dos dice si se comprueba algo. Un test sin aserciones suma a
LOCt, aJTMy a la cobertura exactamente igual que uno bueno. - El estilo cambia la cifra. Bibliotecas de tests más verbosas, datos incrustados en el código o tests muy
repetitivos inflan
TEST_RATcon la misma cobertura real.
CALLEDt se acerca un poco más, porque mira qué métodos llaman los tests, pero solo ve las llamadas directas
escritas en ficheros de test. Un método privado o auxiliar al que solo llega un test a través de otro método tiene
CALLEDt = 0 y puede estar cubierto; un método con CALLEDt = 5 puede tener sin ejecutar la mitad de sus ramas.
La evidencia empírica matiza, pero no deshace, la diferencia. Inozemtseva y Holmes (2014) generaron miles de suites
para cinco sistemas Java y midieron su eficacia con mutantes: el número de tests de la suite estaba relacionado con
su eficacia, y una vez se controlaba ese número, la correlación entre cobertura y eficacia era baja o moderada.
Zhang y Mesbah (2015), con 6.700 suites de cinco proyectos Java, buscaron por qué el tamaño importa y lo
encontraron en las aserciones: su número se correlaciona fuertemente con la eficacia de la suite e influye
directamente en la relación entre tamaño y eficacia. Es decir, lo que hace útil a un test no son sus líneas, sino
lo que comprueba. Otros estudios, centrados en defectos y no en mutantes, dan resultados menos claros sobre las
aserciones (ver la página de «JTA»).
La escalera, de lo más barato a lo más informativo:
| Pregunta | Métrica | Qué hace falta |
|---|---|---|
| ¿Hay tests aquí? | TEST_RAT, LOCt, JTM |
leer el código |
| ¿Comprueban algo? | JTA / JTM (aserciones por test) |
leer el código |
| ¿Llaman los tests a este método? | CALLEDt |
leer el código |
| ¿Qué ejecutan los tests? | «cobertura» | ejecutar los tests con el código instrumentado |
| ¿Detectarían un error? | «puntuación de mutación» | ejecutar los tests una vez por cada mutante |
Cada peldaño contesta lo que el anterior no puede. La cobertura no ve si se comprueba algo, y la mutación sí; un mutante en código sin cubrir sobrevive siempre, así que la cobertura acota lo que la mutación puede detectar.
Cómo se combinan
Aserciones por test. JTA dividido entre JTM es la lectura más útil de las dos. Un promedio de 0 en una
clase de test suele ser tests que solo comprueban que no salta una excepción, o que comprueban con métodos que JTA
no reconoce. Un promedio muy alto suele ser un test que
lo prueba todo a la vez y que, cuando falla, no dice por qué. Ten en cuenta que JTA cuenta por nombre: un
assertThat(x).isEqualTo(y) suma 1, y un verify(...) de una biblioteca de mocks no suma nada. Y que un método
parametrizado con cien filas de datos suma 1 a JTM.
Líneas de test frente a producción. TEST_RAT se construye con LOCt y con las
«líneas de producción» (LOCp). Para comparar sin comentarios usa
NCLOCt frente a «NCLOCp»; para comparar en clases, Ct frente
al «número de clases de producción» (Cp). Es una proporción del total,
no un cociente test entre producción: un 50 % es una línea de test por cada una de producción.
TEST_RAT por paquete y por módulo. En el paquete se juntan los ficheros de producción y de test con el mismo
nombre de paquete; un paquete que solo existe en los tests da 100 %. Un módulo cuyos tests viven en otro módulo (de
integración, por ejemplo) da un valor bajo sin que le falten tests. En el proyecto se suman las líneas y se divide
una vez, así que los módulos grandes pesan más que los pequeños.
Llamadas desde test y desde producción. CALLEDt es la parte de
«CALLED» que viene de los tests;
«CALLEDp», la que viene de producción. CALLEDt > 0 con
CALLEDp = 0 es un método que solo usan los tests: o es una API que todavía nadie llama, o sobra.
Con la complejidad. Los métodos con mucha «complejidad ciclomática»
son los que más tests necesitan: v(G) es una cota superior de los tests que hacen falta para cubrir todas sus
ramas. Un método con v(G) alta y CALLEDt = 0 es un buen sitio para empezar a escribir tests. La
«guía de complejidad» explica esa métrica.
El código de test en las demás métricas. Muchas métricas de otros aspectos incluyen el código de test: la
complejidad ciclomática de los métodos de test, las líneas de comentario y la cobertura Javadoc de un módulo, por
ejemplo. Cuando quieras hablar solo del producto, usa las variantes de producción del
«aspecto de tamaño» (LOCp, NCLOCp, Cp) o filtra los paquetes de test. La
«guía de documentación» explica cómo bajan los tests la cobertura Javadoc.
Qué no miden
- La cobertura ni la detección de errores. Ya está dicho, pero es lo principal: ninguna métrica estática sustituye a ejecutar los tests. Las páginas de «cobertura» y de «mutación» explican cómo se calculan, qué herramientas lo hacen y cómo se falsean.
- La calidad del código de test. Los tests también se degradan: van Deursen, Moonen, van den Bergh y Kok (2001) describieron un catálogo de test smells, malos olores propios del código de test, con refactorizaciones específicas para eliminarlos. Ninguna métrica del aspecto los detecta.
- Qué clase de test es. Unitarios, de integración y de extremo a extremo cuentan igual. Un
JTMalto puede ser una suite rápida de tests unitarios o una lenta de tests que levantan medio sistema. - Si los tests son fiables. Un test que falla a veces sin que cambie el código (flaky) cuenta igual que uno estable.
- Los tests que no siguen las convenciones.
JTM,JTCyJTAbuscan las anotaciones tal cual: un método con una anotación propia meta-anotada con@Test, que JUnit 5 sí ejecuta, no cuenta. Tampoco los tests en Kotlin. - Dónde importa tener tests. Las métricas dicen dónde hay pocos, no dónde hacen más falta. Para eso hay que cruzarlas con la complejidad y con la historia de cambios: los «puntos calientes de cambio» señalan el código que más se toca, y la «guía de evolución» explica cómo obtenerlos.
Qué calcula cada herramienta de tests y de cobertura está en «Herramientas». Lo que dicen los estudios sobre tests, cobertura y defectos se resume en «Qué dice la evidencia empírica».
Referencias
- Inozemtseva, L. y Holmes, R. (2014). «Coverage is not strongly correlated with test suite effectiveness». Proceedings of the 36th International Conference on Software Engineering (ICSE), 435-445. https://doi.org/10.1145/2568225.2568271
- Zhang, Y. y Mesbah, A. (2015). «Assertions Are Strongly Correlated with Test Suite Effectiveness». Proceedings of the 10th Joint Meeting on Foundations of Software Engineering (ESEC/FSE 2015), 214-224. https://doi.org/10.1145/2786805.2786858
- van Deursen, A., Moonen, L., van den Bergh, A. y Kok, G. (2001). Refactoring Test Code. Informe técnico SEN-R0119, CWI, Ámsterdam. https://ir.cwi.nl/pub/4324
- Arguelles, C., Ivanković, M. y Bender, A. (2020). «Code Coverage Best Practices». Google Testing Blog. https://testing.googleblog.com/2020/08/code-coverage-best-practices.html
- SonarQube, introducción a los quality gates: https://docs.sonarsource.com/sonarqube-server/latest/quality-standards-administration/managing-quality-gates/introduction-to-quality-gates/