Étude de cas BankNext : Automatisation avec JUnit Mockito

Tutoriels
JUnit

BankNext possède un environnement de production massif avec plus de 300 microservices en direct. Plusieurs équipes travaillant simultanément sur ces SVC augmentent le risque de casser des fonctionnalités. Ajouter des JUnits et une couverture de code manuellement aux codes existants et nouveaux est fastidieux et extrêmement lent.

Défis Avec JUnits Manuel

  1. Activité très chronophage pour écrire des JUnits utiles et appropriés manuellement.
  2. Manque de standardisation car chacun adopte des approches différentes.
  3. JUnits incomplets/incorrects créés en raison du manque de temps.
  4. Synchronisation manuelle des JUnits existants en raison des changements de code est impraticable.
  5. Écrire des JUnits manuellement pour du code legacy est un cauchemar.
  6. Le moins de priorité est accordé aux JUnits en raison des délais; donc, ils sont souvent omis.
  7. La qualité du code en pâtit grandement, et la dette technique s’accumule.

Solution: Automatisation JUnit-Mockito

  1. GitHub 
  2. L’automatisation prend en entrée le nom de la classe et crée des JUnits fonctionnels et légaux.
  3. Ces JUnits générés contiennent les mocks Mockito nécessaires.
  4. Gère les JUnits pour RestControllers, Services, Handlers, classes Kafka, etc.
  5. Ainsi, il atteint plus de 70% de couverture de code dans presque tous les scénarios.

Capacités d’Automatisation

  1. Fonctionne pour les applications basées sur Maven SpringBoot 2.x et 3.x.
  2. Un effort de configuration quasi nul.
  3. Prend le chemin local de votre application & entrées utilisateur très basiques.
  4. Utilise des utilitaires de réflexion pour déduire les détails de la structure de l’application.
  5. Identifie de manière transparente les MockBeans requis.
  6. Génère automatiquement des mocks Mockito « When-Then ».
  7. Génère des rapports de couverture de code Jacoco.

Structure d’un JUnit légal

  1. Portions obligatoires : 3
    1. Appeler la méthode de test cible
    2. Simuler toute interaction qui est externe à cette classe
    3. Vérifier que la sortie réelle correspond à l’assertion/vérification attendue
  2. Identifier et déclarer toutes les classes externes en tant que MockBeans
  3. Faire des stubs des réponses attendues de ces interactions MockBean
  4. Voici les règles de base pour un JUnit fonctionnel et légal
Shell

  

Junit-Mockito  Ground Rules

1- target mtd to be tested createCustomer is a void returnType   
2- external mtd invoked .delete     is a void returnType
3- when-then   :  doNothing whenInvoke .delete
4- assertion    :  verify .delete called 1 times  

1- target mtd to be tested createCustomer is a void returnType   
2- external mtd invoked .save          is a Customer returnType
3- when-then   :  when  save then return new Customer
4- assertion    :  verify .save called 1 times

1- target mtd to be tested createCustomer is a Customer returnType   
2- external mtd invoked .save          is a Customer returnType
3- when-then   :  when  save then return new Customer
4- assertion    :  assert result instanceof Customer / Customer is not null

1- target mtd to be tested createCustomer is a Customer returnType   
2- external mtd invoked .findAll          is a List returnType
3- when-then   :  when findAll then return new ArrayList
4- assertion    :  assert result instanceof List / List.size >0

Démo d’automatisation

Voir la démo ici.

Shell

  

cd C:\Vijay\Java              [your local machine path]
git clone https://github.com/vijayredkar/junit-mockito-automation.git

# Structure finale de mon répertoire
# C:\Vijay\Java\AutomationJunitMockito\appsetup
# C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\junit-automation 

cd C:\Vijay\Java\AutomationJunitMockito\appsetup
setup.bat

------- Étapes de la démo ------
https://vijayredkar.medium.com/banknext-case-study-junit-mockito-automation-ac9f6b72cfcc
https://github.com/vijayredkar/junit-mockito-automation

C:\Vijay\Java\AutomationJunitMockito\appsetup

demo scenario -1
com.banknext.customer.mgt.service.CustomerServiceImplType1   
com.banknext.customer.mgt.controller.CustomerMgtControllerType1 

demo scenario -2
com.banknext.customer.mgt.service.CustomerServiceImplType2   
com.banknext.customer.mgt.controller.CustomerMgtControllerType2                 

demo scenario -3
com.banknext.customer.mgt.event.publisher.CustomerTxnPublisherType1             
com.banknext.customer.mgt.event.consumer.CustomerTxnConsumerType1               

demo scenario -4
https://github.com/bezkoder/spring-boot-h2-database-crud/tree/master
cd C:\Vijay\Java\projects\junit-mockito-mgt\test-projects
#git clone https://github.com/bezkoder/spring-boot-h2-database-crud.git
cd C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\spring-boot-h2-database-crud
mvn clean install

cd C:\Vijay\Java\AutomationJunitMockito\appsetup
run setup.bat

cd C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\spring-boot-h2-database-crud
mvn clean install
import in Eclipse
add POM dependencies
check current Jacoco code coverage
 

continue automation run 
check/adjust generated Junits
check current Jacoco code coverage
cd C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\spring-boot-h2-database-crud

check new Jacoco code coverage

run all tests 
cd C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\spring-boot-h2-database-crud
mvn clean install
check again all Jacoco code coverage

C:\Vijay\Java\projects\junit-mockito-mgt\test-projects\spring-boot-h2-database-crud\src\main\java\com\bezkoder\spring\jpa\h2
com.bezkoder.spring.jpa.h2.controller.TutorialController
com.bezkoder.spring.jpa.h2.model.Tutorial
TutorialController

Avant et Après Exécution de l’Automatisation

Conclusion

  1. BankNext économise un temps et un effort considérables avec la création automatique de JUnit.
  2. Cela se traduit directement par des économies de coûts de projet.
  3. La couverture de code augmente considérablement.
  4. L’équipe est en mesure de se concentrer entièrement sur les activités de développement réel.
  5. Les JUnits sont ajoutés/maintenus de manière constante avec un effort manuel presque nul.
  6. La dette technique est réduite de manière significative.
  7. Renforce grandement la confiance dans les applications déployées en production.

Source:
https://dzone.com/articles/banknext-case-study-junit-mockito-automation-1