Número de aserciones de test JUnit
| Sigla | JTA (JTA(rec) en la variante recursiva del paquete) |
| Aspecto | «Tests» |
| Se mide en | clase, paquete, módulo, proyecto |
| Tipo de valor | recuento (entero, mínimo 0) |
| Dirección | informativa: ni alto ni bajo es mejor |
| Stau Metro | NumTestAssertsClass, NumTestAssertsPackage, NumTestAssertsRecursivePackage, NumTestAssertsModule, NumTestAssertsProject |
En pocas palabras
Cuenta las comprobaciones que hacen los tests: las llamadas a assertEquals, assertTrue, fail y similares dentro
de un método de test. Un test sin ninguna solo comprueba que el código se ejecuta sin romperse.
Qué mide
Cuánto verifica una suite, frente a cuánto ejecuta. Los tests que llaman al código pero no comprueban el resultado suben la cobertura sin detectar errores. El número de aserciones es una señal de que hay comprobaciones; no dice si son las correctas.
Dividida entre los «métodos de test», da el promedio de aserciones por test, la forma habitual de usarla (la literatura habla de assertion density, densidad de aserciones).
Ojo. No confundas esta métrica con el «número de sentencias
assert», que cuenta la palabra claveassertdel lenguaje en el código de producción y de test.JTAcuenta llamadas a métodos.
Cómo se calcula
Ejemplo
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import org.junit.jupiter.api.Test;
record Order(List<Integer> items) {
int total() { return items.stream().mapToInt(Integer::intValue).sum(); }
}
class OrderTest {
private final Order order = new Order(List.of(10, 20));
@Test void total() {
assertEquals(30, order.total()); // +1
assertAll( // +1
() -> assertTrue(order.total() > 0), // +1 (lambda dentro del método de test)
() -> assertFalse(order.items().isEmpty())); // +1
}
@Test void smoke() { order.total(); } // 0
@Test void valid() { assertValid(order); } // +1 (el nombre empieza por assert)
private void assertValid(Order o) { assertNotNull(o); } // 0: no es un método de test
}
JTA = 4 + 0 + 1 = 5, con 3 métodos de test: 1,67 aserciones por test. El assertNotNull del método auxiliar
no cuenta porque su método no es de test; la llamada a assertValid sí, una vez, aunque dentro haya más
comprobaciones.
Cómo interpretarla
Un valor de 0 en un método de test (o en una clase con tests) indica que no comprueba nada. Un valor alto indica
muchas comprobaciones, lo cual puede ser bueno (cubre casos) o malo (un test que lo prueba todo y falla por muchas
causas). Observa el promedio por test, no el total.
Sin umbrales de referencia. Compara clases similares entre sí.
Para profundizar
La densidad de aserciones se ha estudiado como indicador de calidad. Kudrjavets, Nagappan y Ball (2006), en dos componentes comerciales de Microsoft, encontraron que los ficheros con más densidad de aserciones tenían una densidad de defectos significativamente menor; eran las aserciones del propio código, no las de los tests. Counsell et al. (2017), sobre las clases de test de dos sistemas Java industriales, encontraron poca evidencia a favor de un resultado anterior de Casalnuovo et al. (que los métodos con aserciones tienen menos defectos). Catolino, Palomba, Zaidman y Ferrucci (2019) definen la densidad de aserciones como aserciones por KLOC de las clases de test y, en 12 proyectos de código abierto, la relacionan con la experiencia del equipo. En conjunto: más aserciones no equivale a mejor suite.
El recuento por nombre tiene límites. Cuenta assertThat(x) de Hamcrest o AssertJ como una aserción aunque la
cadena .isEqualTo(...) que le sigue haga la comprobación real, y no ve las comprobaciones con otros nombres
(verify, expect, check).
Relación con otras métricas
- «Número de métodos de test JUnit» (
JTM): el denominador del promedio de aserciones por test. - «Número de sentencias assert» (
ASSERT): otra cosa, la palabra claveassert. - «Cobertura de código» y «puntuación de mutación»: miden qué ejecutan y qué detectan los tests; las aserciones son lo que hace posible detectar.
- «Número de casos de test JUnit» (
JTC): las clases de test.
En las herramientas
Stau Metro (NumTestAssertsClass, NumTestAssertsPackage, NumTestAssertsRecursivePackage,
NumTestAssertsModule, NumTestAssertsProject). Cuenta las llamadas a método cuyo nombre empieza por assert o es
fail, y cuyo método contenedor más próximo es un método de test (mismo reconocimiento que
«JTM»).
- El nombre se mira sin importar a qué clase pertenece el método:
Assertions.assertEquals,assertThatde otra biblioteca o un método propioassertValidcuentan igual. - Las llamadas dentro de lambdas del método de test cuentan; las de un método de una clase anónima o local interna, no, porque su método contenedor no es de test.
- A nivel de clase, las llamadas de las clases anónimas o locales se suman a la clase que las contiene; las clases anidadas con nombre tienen su fila propia. No se publica valor para las interfaces ni para los tipos anotación.
- No se limita a las raíces de test: lo que decide es que el método contenedor se reconozca como método de test.
- Solo Java.
Referencias
- Kudrjavets, G., Nagappan, N. y Ball, T. (2006). «Assessing the Relationship between Software Assertions and Code Quality: An Empirical Investigation». Informe técnico MSR-TR-2006-54, Microsoft Research. https://www.microsoft.com/en-us/research/publication/assessing-the-relationship-between-software-assertions-and-code-qualityan-empirical-investigation/
- Catolino, G., Palomba, F., Zaidman, A. y Ferrucci, F. (2019). «How the Experience of Development Teams Relates to Assertion Density of Test Classes». IEEE International Conference on Software Maintenance and Evolution (ICSME 2019), 223-234.
- Counsell, S., Hall, T., Shippey, T., Bowes, D., Tahir, A. y MacDonell, S. (2017). «Assert Use and Defectiveness in Industrial Code». IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW 2017), 20-23. Versión en arXiv: https://arxiv.org/abs/2104.01514