Tests en Java - Rappel ou Apprentissage

.

Une question courante lors de la construction d'une suite de tests unitaires est de savoir comment organiser nos tests de manière sensée. Il existe différentes approches, mais en Java un idiome commun est d'avoir une classe de test par classe de projet, où la classe de test rassemble tous les tests qui testent les méthodes ou autres scénarios d'utilisation qui impliquent la classe.

De plus, il est de pratique courante de localiser tout le code de test dans un dossier source différent avec une structure de paquet qui reflète la structure du paquet du code de production. La raison d'être de cette organisation est que dans Java les classes avec le même nom de paquet sont dans la même portée de paquet indépendamment de leur emplacement dans un système de fichiers. Cela signifie que les classes et les méthodes du paquet de test peuvent se référer à des classes non publiques (mais non-privés) des membres des classes du code de production, tout en étant toujours séparés du code de production.

Écrire des tests unitaires pour des classes non triviales est souvent un processus créatif difficile, un peu comme écrire un code de production. Pour cette raison, il n'existe pas de formule ou de modèle standard pour écrire le code d'un test unitaire. En fait, parcourir les suites de tests de différents projets open-source montrera que les différentes communautés suivent des styles différents et utilisent des techniques de test différentes. Ceci étant dit, certains principes de base sont généralement acceptés, notamment que les tests unitaires doivent être rapides, indépendants, répétitifs, ciblés et lisibles[1].

• Rapides. Les tests unitaires sont destinés à être exécutés souvent, et dans de nombreux cas dans le cadre d'un cycle de programmation-compilation-exécution. Pour cette raison, n'importe quelle suite de tests exécutée devrait être capable de se terminer en quelques secondes. Sinon, les développeurs seront tentés d'omettre de les exécuter, et les tests cesseront d'être utiles. Cela signifie que les tests unitaires doivent éviter les opérations de longue haleine telles que les E/S d'appareils intensifs et l'accès au réseau, et laisser le test de ces fonctions à d'autres tests que les tests unitaires. Il peut s'agir, par exemple, de tests d'acceptation ou d'intégration.
• Indépendant. Chaque test unitaire devrait pouvoir être exécuté de façon isolée. Cela signifie, par exemple, qu'un test ne doit pas dépendre du fait qu'un autre test s'exécute avant de laisser un objet d'entrée dans un certain état. Premièrement, il est souvent souhaitable de n'effectuer qu'un seul test. Deuxièmement, tout comme le code, les suites de tests évoluent, avec l'ajout de nouveaux tests et (dans une moindre mesure) la suppression de certains tests. L'indépendance des tests facilite l'évolution de la suite de tests. Enfin, JUnit et d'autres tests de conception similaire n'offrent aucune garantie que les tests seront exécutés dans un environnement prévisible ou- der. En pratique, cela signifie que chaque test doit commencer par une nouvelle initialisation de l'état utilisé dans le cadre du test.
• Répétable. L'exécution de tests unitaires devrait produire le même résultat dans des environnements différents (par exemple, lorsqu'ils sont exécutés sur des systèmes d'exploitation différents). Cela signifie que les oracles de test ne doivent pas dépendre de caractéristiques propres à l'environnement, telles que la taille de l'affichage, la vitesse du CPU ou les polices système.
• Concentré. Les tests doivent exercer et vérifier une partie du comportement d'exécution du code qui est aussi étroite que raisonnablement possible. La raison d'être de ce principe est que le but des tests unitaires est d'aider les développeurs à identifier les pannes. Si un test unitaire comprend 500 lignes de code et teste toute une série d'interactions complexes entre objets, il ne sera pas facile de déterminer ce qui a mal tourné en cas d'échec. En revanche, un test qui vérifie une seule entrée sur un seul appel de méthode facilitera le repérage d'un problème. Certains ont même soutenu que les tests unitaires devraient comporter une seule affirmation[1]. Mon opinion ¹⁾ est que dans de nombreux cas, cela est trop strict et peut conduire à des inefficacités. Toutefois, les tests devraient idéalement se concentrer sur un seul aspect d'une unité à l'essai. Si l'unité testée est une méthode, nous pouvons l'appeler méthode focale pour le test.
• Lisible. La structure et le style de codage du test devraient faciliter l'identification de toutes les composantes du test (unité sous test, données d'entrée, oracle), ainsi que la justification du test. Testons-nous l'initialisation d'un objet ? Un cas particulier ? Une combinaison particulière de valeurs ? Le choix d'un nom approprié pour le test peut souvent aider à clarifier sa raison d'être.

En utilisant l'annotation @BeforeEach, nous indiquons à JUnit d'exécuter la méthode avant l'exécution de tout test. De même, il est également possible d'utiliser la notation @After Après une notation annotation pour marquer une méthode qui doit être exécutée après chaque test (par exemple pour libérer certaines ressources). Bien sûr, les objets immuables n'ont pas besoin d'être réinitialisés, ils peuvent donc être stockés comme champs statiques de la classe.

Une fixture est un morceau de code qui permet de fixer un environnement logiciel pour exécuter des tests logiciels. Cet environnement constant est toujours le même à chaque exécution des tests. Il permet de répéter les tests indéfiniment et d'avoir toujours les mêmes résultats. (Wikipedia)

package testRobillardBook;
 
import static org.junit.jupiter.api.Assertions.*;
 
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
 
public class TestFoundationPile {
                // Test Fisture
		private static final Card ACE_CLUBS = Card.get(Rank.ACE, Suit.CLUBS);
		private static final Card TWO_CLUBS = Card.get(Rank.TWO, Suit.CLUBS);
		private static final Card THREE_CLUBS = Card.get(Rank.THREE, Suit.CLUBS);
		private FoundationPile aPile;
		@BeforeEach
		public void setUp() { aPile = new FoundationPile(); }
 
		@Test
		public void testCanMoveTo_Empty() {
		    assertTrue(aPile.canMoveTo(ACE_CLUBS));
		    assertFalse(aPile.canMoveTo(THREE_CLUBS));
		  }
		@Test
		public void testCanMoveTo_NotEmptyAndSameSuit() {
		    aPile.push(ACE_CLUBS);
		    assertTrue(aPile.canMoveTo(TWO_CLUBS));
		    assertFalse(aPile.canMoveTo(THREE_CLUBS));
		} }
}

Il n'est pas toujours physiquement possible de tester de façon exhaustive l'espace d'entrée d'un projet. Par exemple, pour tester toutes les comparaisons de deux cartes d'un jeu de 54 cartes, il faudrait faire 1431 tests (ce qui reste faisable), mais pour tester les positions sur un jeu de dames, il y a 443 748 401 247 positions. Même avec un CPU de pointe, tester une méthode pour toutes les positions possibles cela prendrait beaucoup trop de temps et ceci est tout à fait incompatible avec l'exigence selon laquelle les tests unitaires doivent être exécutés “rapidement”.

De toute évidence, nous devons choisir les tests à réaliser parmi toutes les possibilités (par exemple, sélectionner les configurations du jeu de dame à tester). Le défi fondamental du problème de sélection des cas de test est de tester efficacement, c'est-à-dire de trouver un ensemble minimal de cas de test qui nous fournisse une quantité maximale de “test” pour notre code. Malheureusement, bien qu'il soit assez évident de savoir ce qu'est un nombre minimal de cas de test, il n'existe pas de définition naturelle ou même convenue de ce qu'est une “quantité de test”.

Une méthode classique pour déterminer ce qu'il faut tester est basée sur le concept de couverture. De manière informelle, une mesure de couverture de test est un nombre (généralement un pourcentage) qui détermine la quantité de code exécutée lorsque nous exécutons nos tests. Les mesures de couverture de test peuvent ensuite être calculées par des outils de couverture de code qui gardent la trace du code qui est exécuté lorsque nous exécutons des tests unitaires. Cela peut paraître simple, mais le problème est qu'il existe différentes définitions de ce que l'on peut entendre par “code”, dans le contexte des tests. Chaque définition est une façon différente de calculer “combien de tests” sont effectués. Certaines organisations de développement de logiciels peuvent avoir des critères d'adéquation des tests bien définis selon lesquels les suites de tests doivent atteindre certains seuils de couverture, mais dans de nombreux autres cas, les informations fournies par les mesures de couverture sont utilisées plus généralement pour aider à déterminer où investir les futurs efforts de test. Voici trois paramètres de couverture bien connus (il y en a beaucoup d'autres, voir Lectures complémentaires).

La couverture des instructions est simplement le nombre d'instructions exécutées par un test ou une suite de tests, divisé par le nombre d'instructions dans le code d'intérêt.

	public boolean canMove() {
		if( isEmpty() )
			return false;
		else 
			return true;
	}

Le test suivant ne couvre alors que les premières instructions soit 60% du code de la méthode.

@Test
	public void testCanMove_Empty()
	{
		aPile = new FoundationPile();
		assertFalse(aPile.canMove());
	}

La logique qui sous-tend la couverture des instructions est simplement que si un défaut est présent dans une instruction qui n'est jamais exécutée, les tests ne vont pas aider à le trouver. Bien que cette logique puisse sembler attrayante, la couverture des relevés est en fait une mauvaise mesure de couverture. Une première raison est que cela dépend fortement de la structure détaillée du code. Nous pourrions réécrire la méthode canMove comme suit, et atteindre une couverture de test de 100% avec exactement les mêmes tests.

	public boolean canMove() {
		return !(isEmpty());
	}

La deuxième raison est que toutes les instructions ne sont pas créées de la même manière, et il peut y avoir beaucoup de choses qui se passent dans une instruction, surtout si cette instruction implique une expression booléenne composée (comme c'est le cas de la première instruction dans le dernier exemple).

La couverture des branches est le nombre de “branches” du programme (points de décision) exécutées par le(s) test(s) divisé(s) par le nombre total de branches dans le code qui nous intéresse. Dans ce contexte, une branche est un résultat d'une condition. La couverture des branches est une mesure plus fiable que la couverture des instructions, en ce sens que, pour le même résultat de couverture, un plus grand nombre d'exécutions possibles de programmes auront été testées. Malheureusement, le concept de couverture des branches est un peu ambigu dans la littérature, en raison des différentes interprétations possibles du terme “branche”. Dans le code de canMoveTo ci-après, il n'y a que deux branches si l'on considère l'instruction “if”.

	public boolean canMoveTo(Card pCard)
	{
		if( isEmpty() )
		{
			return pCard.getRank() == Rank.ACE;
		}
		else
		{
			return pCard.getSuit() == peek().getSuit() &&
					pCard.getRank().ordinal() ==
					peek().getRank().ordinal()+1;
		}
	}
 

Cependant, les branches vraies et fausses conduisent toutes deux à des instructions qui sont constituées d'expressions booléennes, qui sont elles-mêmes un autre type de branche. Pour être cohérent avec les outils populaires d'analyse de l'âge de couverture, j'adopte la définition que les expressions booléennes dans les instructions introduisent également des branches. Bien que plus complexe à déterminer, cette définition est également plus utile. Avec cette définition, le code original de canMoveTo présente huit branches : le si, le premier relevé de retour, la première comparaison dans le deuxième relevé de retour, et la deuxième comparaison dans le deuxième relevé de retour. Chacune de ces branches a un résultat vrai et faux. Le seul test écrit jusqu'à présent ne couvre que 3/8 = 37,5 % des branches.

D'une manière générale, la couverture des branches est l'un des critères de couverture des tests les plus utiles. Elle est bien étayée par des outils de test et relativement facile à interpréter, et englobe également la couverture des instructions, ce qui signifie qu'obtenir une couverture complète des instructions implique toujours une couverture complète des branches.

EclEmma est un outil gratuit de couverture de code Java pour Eclipse, disponible sous la licence publique Eclipse. Il apporte l'analyse de couverture de code directement dans l'atelier Eclipse. Depuis la version 2.0, EclEmma est basé sur la bibliothèque de codes JaCoCoCo. L'intégration d'Eclipse a pour but d'aider le développeur individuel de manière hautement interactive.

Vous avez différents types de compteurs à disposition (voir https://www.jacoco.org/jacoco/trunk/doc/counters.html):

et pour mieux comprendre les codes en couleur : https://www.eclemma.org/userdoc/annotations.html

Aujourd'hui il y a deux façons fondamentales d'aborder la sélection des cas de test :

• Les tests fonctionnels (ou de boîte noire) tentent de couvrir autant que possible le comportement spécifié d'un programme, en se basant sur certaines spécifications externes de ce que le programme doit faire en particulier au travers de post-condition(Nous verrons également que dans le processus de production d'un programme, on prévoit des tests à réaliser dans les histoires utilisateurs). Les tests de boîte noire présentent de nombreux avantages, notamment le fait qu'il n'est pas nécessaire d'accéder au code, que les tests peuvent révéler des problèmes dans la spécification.
• Les tests structurels (ou de boîte blanche) tentent de couvrir autant que possible le comportement implémenté d'un programme, sur la base d'une analyse du code source de l'unité à tester. Le principal avantage du test des boîtes blanches est qu'il peut révéler des problèmes causés par des détails d'implémentation de bas niveau qui sont invisibles au niveau de la spécification.

1. Robert C. Martin. Clean Code: A Handbook of Agile Software Craftmanship. Prentice Hall, 2009.
2. Le livre de référence : https://coderprog.com/introduction-software-design-java/
3. Les codes sources associés au livre : https://github.com/prmr/DesignBook