Utilisez JUnit 5 et Mockito pour isoler efficacement les dépendances pour les tests unitaires. 1. Créer des objets simulés via @Mock, @InjectMocks Inject L'instance testée, @ExtendWith Activer la Mockito Extension; 2. Utiliser quand (). ThereTreturn () pour définir le comportement de simulation, vérifiez () pour vérifier le nombre d'appels et de paramètres de méthode; 3. Peut simuler les scénarios d'exception et vérifier la gestion des erreurs; 4. Recommander l'injection du constructeur, éviter une sur-simulation et maintenir l'atomicité des tests; 5. Utiliser Asssertall () pour fusionner les affirmations, et @nest organise des scénarios de test pour améliorer la maintenabilité et la fiabilité des tests.

Les tests unitaires et la moquerie sont des moyens importants pour garantir la qualité du code en Java, et Junit 5 et Mockito sont la combinaison la plus populaire de cadres de test. Ils travaillent ensemble pour isoler efficacement la logique commerciale, en particulier pour les scénarios qui reposent sur des services externes, des bases de données ou des objets complexes.

Pourquoi utiliser Junit 5 Mockito?

JUnit 5 est un cadre de test unitaire grand public en Java, offrant des modèles d'annotation plus flexibles, des mécanismes d'extension et des fonctions d'assertion. Mockito est un framework moqueur puissant qui vous permet de créer et de configurer des objets "faux" pour remplacer les dépendances réelles, en vous concentrant ainsi sur le test du comportement des classes cibles.

La combinaison des deux vous permettra de:

• Isoler le code testé à partir des dépendances externes
• Vérifiez le nombre d'appels et de paramètres de méthode
• Simuler des exceptions et des conditions aux limites
• Améliorer la maintenabilité des tests et la vitesse d'exécution

1. Construction de l'environnement de base

Assurez-vous d'abord que le projet présente les dépendances JUnit 5 et Mockito. Si vous utilisez Maven, ajoutez ce qui suit à pom.xml :

 <dépendances>
    <! - Junit 5 ->
    <dépendance>
        <groupId> org.junit.jupiter </rompgroud>
        <ArtefactId> JUnit-Jupiter </ ArfactId>
        <version> 5.10.0 </ version>
        <ccope> Test </ccope>
    </Dependance>

    <! - Mockito ->
    <dépendance>
        <groupId> org.mockito </rombandid>
        <ArtefactId> Mockito-core </letefactive>
        <version> 5.7.0 </ version>
        <ccope> Test </ccope>
    </Dependance>

    <! - Prise en charge de Mockito Junit Jupiter (facultatif, utilisé pour l&#39;initialisation automatique de l&#39;annotation @mock) ->
    <dépendance>
        <groupId> org.mockito </rombandid>
        <ArtefactId> mockito-junit-jupiter </ arfactive>
        <version> 5.7.0 </ version>
        <ccope> Test </ccope>
    </Dependance>
</DENDENDENCES>

Assurez-vous également d'utiliser une configuration de build qui prend en charge JUnit 5 (tel que SureFire Plugin version> = 2.22.0).

2. Utilisez Mockito pour simuler les objets de dépendance

Supposons que nous ayons un service d'ordre de service OrderService qui repose sur une interface de paiement de paiement PaymentGateway passerelle:

 Interface publique Paymentgateway {
    Charge booléenne (double montant);
}

classe publique OrderService {
    PAYS PAYS PAYS PAYSGATE PAYSGATEWAY;

    ORDERSERVICE PUBLIQUE (PAYSGATEWAY PAYSGATEWAY) {
        this.paymentgateway = PaymentGateway;
    }

    Public Boolean Processorder (double quantité) {
        if (montant <= 0) renvoie false;
        Retour PaymentGateway.Charger (montant);
    }
}

Nous voulons tester OrderService.processOrder() mais ne voulons pas appeler réellement le système de paiement. Pour le moment, vous pouvez utiliser Mockito pour créer un PaymentGateway simulé.

écrire des classes de test

 import org.junit.jupiter.api.test;
import org.mockito.injectmocks;
import org.mockito.mock;
Importer Static org.junit.jupiter.api.Assesertions. *;
importer statique org.mockito.mockito. *;

classe OrderServiceTest {

    @Se moquer
    PAYS PAYSGATE PAYS PAYSGATEWAY;

    @Injectmocks
    Commande d'ordre privé;

    // doit coopérer avec MockitoExtension pour initialiser automatiquement @Mock et @InjectMocks
    @ org.junit.jupiter.api.extension.extendWith (mockitoextension.class)
    classe statique imbriquée {}

    @Test
    void doit-ilturfalse_whenamountisinvalid () {
        // appelle la méthode sous test booléen result = orderservice.processOrder (-100);

        // Affirmer le résultat AssertFalse (résultat);

        // Vérifiez que la passerelle de paiement n'est pas appelée vérification (PaymentGateway, jamais ()). Charge (anyDouble ());
    }

    @Test
    void doit-onTrue_WhenPaymentsUCceeds () {
        // Simuler le comportement de dépendance lorsque (PAYSGATEWAY.CHARGE (100.0)). ThereAtturn (true);

        // Exécuter Boolean Result = OrderService.ProcessOrder (100.0);

        // affirmer AssertTrue (résultat);
        Vérifier (PAYSGATEWAY) .Charger (100.0);
    }

    @Test
    void doit-onTurnfalse_WhenPaymentFails () {
        quand (PaymentGateway.Charger (100.0)). ThereAtturn (false);

        Résultat booléen = OrderService.ProcessOrder (100,0);

        AssertFalse (résultat);
        Vérifier (PAYSGATEWAY) .Charger (100.0);
    }
}

Description des points clés:

• @Mock : Créez un objet simulé (Mock)
• @InjectMocks : créez une instance de classe cible et injectez automatiquement les champs @Mock étiquetés (via le constructeur ou l'injection de champ)
• @ExtendWith(MockitoExtension.class) : Activez l'extension Junit de Mockito pour initialiser automatiquement les annotations
• when(...).thenReturn(...) : Définissez la valeur de retour de la méthode de simulation
• verify(...) : Vérifiez si une méthode a été appelée, ainsi que le nombre d'appels, de paramètres, etc.

3. Vérification du comportement

En plus d'affirmer la valeur de retour, vous pouvez également vérifier que la méthode est appelée correctement. Par exemple:

 @Test
vide doit être titulaire de bord
    quand (PaymentGateway.Charger (50.0)). ThereAtturn (true);

    ORDERSERVICE.PROCESSORSE (50.0);

    // Vérifiez que la méthode de charge est appelée une fois et que le paramètre est 50.0
    Vérifier (PaymentGateway, Times (1)). Charge (Eq (50.0));
}

Autres méthodes de vérification courantes:

• never() : jamais appelé
• atLeastOnce() : au moins une fois
• timeout(100) : appelé dans un délai spécifié (pour asynchrone)
• inOrder(...) : Vérifiez l'ordre d'appel

 // Exemple: vérifiez l'ordre d'appel inOrder inOrder = inOrder (PaymentGateway);
inOrder.Verify (PaymentGateway) .Charger (30.0);
inOrder.Verify (PaymentGateway) .Charger (20.0);

4. Gérer les exceptions et les situations de limite

Vous pouvez avoir les exceptions de lancement d'objet simulé et tester la logique de gestion des erreurs:

 @Test
void sihandlepaymentFailureDueToException () {
    quand (PaymentGateway.Charger (100.0)). ThentHrow (nouveau RuntimeException ("Erreur de réseau"));

    assertThrows (runtimeException.class, () -> {
        OrderService.ProcessOrder (100.0);
    });

    Vérifier (PAYSGATEWAY) .Charger (100.0);
}

Vous pouvez également utiliser doThrow() pour coopérer avec doReturn() pour gérer des méthodes void ou des scénarios spéciaux.

5. Conseils et meilleures pratiques

• évitez la suresimulation : simulez uniquement les dépendances qui ont vraiment besoin d'isolement et ne simulez pas l'intégralité du lien
• Injection de constructeur préférée : des objets simulés faciles à passer pendant les tests
• Maintenir l'atomicité du test : un test valide uniquement un comportement
• Affirmation par lots utilisant assertAll()

 @Test
void multipleassertions () {
    Quand (Paytgateway.Charger (100.0)). ThereAtturn (true);

    Résultat booléen = OrderService.ProcessOrder (100,0);

    Assertall (
        () -> assertTrue (résultat),
        () -> Vérifier (PaymentGateway) .Charger (100.0)
    ));
}

• Utilisez la classe de test @Nested pour organiser différents scénarios:

 @Nest
classe WhenamountIspositive {
    @Test
    VOID SOUHNACHARGEPAYMENTGATEWAY () {...}
}

Fondamentalement, c'est tout. La combinaison de Junit 5 Mockito rend les tests unitaires Java intuitifs et puissants. La clé est de comprendre le ?comportement de test? plut?t que la ?mise en ?uvre du test? et de contr?ler les dépendances via Mock pour s'assurer que le test est rapide, stable et reproductible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!