Questions Posées sur les Tests durant un Entretien

Quelle est la différence entre Junit et Mockito ?

JUnit est un framework de test unitaire qui fournit une structure pour écrire et exécuter des tests, tandis que Mockito est un framework de simulation qui permet de créer des objets simulés pour remplacer les dépendances dans les tests unitaires. Ils sont souvent utilisés ensemble pour écrire des tests unitaires efficaces et isolés en Java.

JUnit fournit des assertions prédéfinies (telles que assertEquals, assertTrue, assertFalse, etc.) pour valider le comportement attendu du code testé. Il permet également de définir des méthodes d’initialisation et de nettoyage pour configurer l’état des tests.

Il fournit des annotations telles que @Mock pour créer des simulations et des méthodes telles que when() et thenReturn() pour spécifier le comportement des simulations.

Dans Junit, quelles sont les annotations les plus utilisées ?

Dans JUnit, les annotations les plus couramment utilisées pour écrire des tests unitaires sont les suivantes :

Quelles sont les annotations les plus utilisées dans mockito ?

Dans Mockito, les annotations les plus couramment utilisées pour la simulation d’objets et les tests unitaires sont les suivantes :

Quelle est la fonctionnalité majeure ajouté à Junit5 par rapport à Junit4 ?

JUnit 5 apporte de nombreuses améliorations par rapport à JUnit 4, y compris de nouvelles fonctionnalités, une architecture modulaire, un support amélioré pour les tests paramétrés et les extensions, ainsi que des annotations révisées.

A quoi servent les tests paramétrés ?

Les tests paramétrés permettent de réduire la duplication de code en regroupant les tests similaires, facilitant ainsi la maintenance et l’extension des suites de tests. Ils offrent également une meilleure couverture de test en testant plusieurs combinaisons de données d’entrée. Voici un exemple d’utilisation :

import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.stream.Stream;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
public class MathUtilsTest {
    @ParameterizedTest
    @MethodSource("dataProvider")
    void testAddition(int a, int b, int expectedResult) {
        MathUtils mathUtils = new MathUtils();
        assertEquals(expectedResult, mathUtils.add(a, b));
    }
    static Stream<Object[]> dataProvider() {
        return Stream.of(
            new Object[]{1, 1, 2},
            new Object[]{2, 3, 5},
            new Object[]{-1, -1, -2},
            new Object[]{0, 0, 0}
        );
    }
    public class MathUtils {
        public static int add(int a, int b) {
            return a + b;
        }
    }
}

A quoi servent les approches TDD, BDD et DDD ?

Les trois approches peuvent être utilisées de manière complémentaire pour développer des logiciels de manière itérative, axée sur le domaine et testée de manière rigoureuse. La TDD se concentre sur la rédaction de tests unitaires pour guider le développement du code, BDD met l’accent sur les comportements attendus du système exprimés en termes compréhensibles par les parties prenantes, et la DDD vise à modéliser le domaine métier d’une manière qui reflète fidèlement la réalité du domaine.

1. Test-Driven Development (TDD) :

   • TDD est une approche de développement logiciel où les tests unitaires sont écrits avant même que le code de production ne soit implémenté. Le cycle de développement de la TDD suit généralement les étapes “Red”, “Green”, et “Refactor”. Les tests unitaires servent de spécifications pour guider l’implémentation du code de production.

2. Behavior-Driven Development (BDD) :

   • BDD est une extension de la TDD qui met l’accent sur le comportement attendu du système plutôt que sur ses fonctionnalités internes. Les spécifications sont écrites sous forme de scénarios compréhensibles par les parties prenantes, généralement utilisant un langage basé sur des phrases comme Gherkin. Les tests BDD sont généralement écrits en utilisant des outils comme Cucumber ou JBehave.

3. Domain-Driven Design (DDD) :

   • DDD est une approche de conception logicielle qui se concentre sur la modélisation du domaine métier d’une application. Le DDD encourage l’utilisation d’un langage ubiquitaire pour décrire les concepts métier, la création de modèles de domaine riches et expressifs, et la découpe des domaines complexes en sous-domaines plus gérables. Il vise à aligner le code avec les concepts métier, facilitant ainsi la compréhension et la maintenance du système.