Projet Maven utilisant Junit - Vérifier le numéro de compte bancaire

Toutes les applications, quelle que soit leur taille, doivent passer par une série de processus de création, de génération, de compilation et d'exécution du code source. Cet ensemble de processus est effectué manuellement par les programmeurs. Cependant, avec le lancement du projet Apache Maven, tous ces processus peuvent être automatisés, éliminant ainsi le travail manuel. Par conséquent, le projet Maven est un outil open source utilisé pour créer et déployer plusieurs projets à la fois afin d'offrir une meilleure gestion de projet.

Dans cet article, nous aborderons un projet Maven pour vérifier si un compte bancaire est valide et le tester avec Junit.

Qu'est-ce que Junit ?

JUnit est un framework de tests unitaires open source utilisé par les organisations de langage Java du monde entier. Dans le langage Java, chaque fois qu'un nouveau code est ajouté, les cas de test doivent être réexécutés. Cette fonction est implémentée par le framework Junit. Il est utilisé pour écrire et exécuter des cas de tests automatisés en langage Java.

Projet Maven pour vérifier un compte bancaire

Chaque fois que nous avons affaire à un logiciel bancaire ou à des applications associées, une chose obligatoire est de vérifier le numéro de compte. Pour qu'un compte soit valide, trois conditions doivent être remplies.

Les trois conditions sont les suivantes -

• Le numéro de compte bancaire ne peut contenir que 14 chiffres.

• Les 14 chiffres du numéro de compte ne peuvent pas être nuls.

• Le champ du numéro de compte ne peut pas être vide ou vide.

Maintenant, écrivons la logique métier qui satisfait à ces trois conditions dans le projet Maven.

Algorithme

• Étape 1 - Créez d'abord un dossier BankingAccountNoServices qui contient un fichier Java nommé BankingAccountNoServices.java pour écrire la logique métier et ensuite TestBankingAccountNoServices.java pour tester la logique métier.

• Étape 2 - Créez un autre fichier pom.xml qui est un fichier XML contenant le projet et les détails de configuration du projet Maven.

• Étape 3 - Un facteur clé pour obtenir un résultat positif est de documenter les informations pertinentes sur le projet et la configuration dans le fichier pom.xml.

• Étape 4 - Rédigez la logique métier en remplissant toutes les conditions nécessaires requises pour vérifier le compte.

• Étape 5 - Écrivez des cas de tests unitaires à l'aide de Junit dans le fichier Test BankingAccountNoServices.java.

Vous devez vérifier le contenu du fichier pom.xml avant de continuer. Il est cohérent dans toutes les méthodes discutées et contient des détails de configuration importants pour les projets Maven.

Exemple

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                              http://maven.apache.org/xsd/maven-4.0.0.xsd">
  
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.BankingAccountNoServices </groupId>
   <artifactId>BankingAccountNoServices </artifactId>
   <packaging>jar</packaging>
   <version>1.0-SNAPSHOT</version>
  
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <maven.compiler.source>1.8</maven.compiler.source>
      <maven.compiler.target>1.8</maven.compiler.target>
      <junit.version>5.3.1</junit.version>
      <pitest.version>1.4.3</pitest.version>
   </properties>
  
   <dependencies>
      <dependency>
         <groupId>org.junit.jupiter</groupId>
         <artifactId>junit-jupiter-engine</artifactId>
         <version>${junit.version}</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <build>
      <finalName>maven-mutation-testing</finalName>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>3.0.0-M1</version>
         </plugin>
  
         <plugin>
            <groupId>org.pitest</groupId>
            <artifactId>pitest-maven</artifactId>
            <version>${pitest.version}</version>
  
            <executions>
               <execution>
                  <id>pit-report</id>
                  <phase>test</phase>
                  <goals>
                     <goal>mutationCoverage</goal>
                  </goals>
               </execution>
            </executions>
  
            <dependencies>
               <dependency>
                  <groupId>org.pitest</groupId>
                  <artifactId>pitest-junit5-plugin</artifactId>
                  <version>0.8</version>
               </dependency>
            </dependencies>
            <configuration>
               <targetClasses>
                  <param>com.example.BankingAccountNoServices.* BankingAccountNoServices *</param>
               </targetClasses>
               <targetTests>
                  <param>com.example.BankingAccountNoServices.*</param>
               </targetTests>
            </configuration>
         </plugin>
  
      </plugins>
   </build>
  
</project>

Le code pom.xml ci-dessus contient tous les détails du projet et de la configuration requis pour notre projet maven.

Méthode

• Méthode 1 - Dans cette méthode, nous verrons la logique métier utilisant Long.parseLong.

• Méthode 2 - Dans cette méthode, nous écrirons la logique métier à l'aide de la fonction Character.isDigit().

• Méthode 3 - Dans cette méthode, nous écrirons une logique métier en utilisant des expressions régulières en Java.

Méthode 1 : utilisez Long.parseLong

Étant donné que le numéro de compte doit être un numéro à 14 chiffres, nous utilisons la fonction Long.parseLong pour le convertir en type long, puis vérifions les trois conditions nécessaires.

Exemple

import java.util.*;  
public class BankingAccountNoServices {
   public boolean isValid1(String accNo) {
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      try {
         Long.parseLong(accNo); 
         if (accNo.length() == 14) {
            int c = 0;
            int n = accNo.length();
            for (int i = 0; i < n; i++) {
               if (accNo.charAt(i) == '0') {
                  c += 1;
               }
            }
            if (c == 14) { 
               return false;
            } else {
               return true;
            }
         } else {
            return false;
         }
      }
      catch (NumberFormatException exception) {
         return false;
      }
   }
}

Dans le code ci-dessus, nous vérifions d'abord si le numéro de compte est nul ou vide, vérifions ensuite si la longueur du numéro de compte est de 14, puis comptons le nombre de zéros qu'il contient. Renvoie faux si les 14 chiffres sont nuls, vrai sinon.

Maintenant, regardons les cas de tests unitaires utilisant JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid1(null));
      assertEquals(false, ob.isValid1("8378939"));
      assertEquals(true, ob.isValid1("67874864837684"));
      assertEquals(true, ob.isValid1("23451234543214"));
   }
}

Dans le code ci-dessus, nous vérifions 4 cas de tests unitaires différents pour vérifier le compte.

Méthode 2 : utilisez Character.isDigit()

Dans cette méthode, nous vérifierons le numéro de compte à l'aide de la fonction Character.isDigit(). Nous vérifierons les trois conditions nécessaires pour vérifier le compte.

Exemple

import java.util.*;  
public class BankingAccountNoServices {
   public boolean isValid2(String accNo){
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      if (accNo.length() == 14) {
         int c = 0;
         for (int i = 0; i < accNo.length(); i++) {
            if (!Character.isDigit(accNo.charAt(i))) {
               return false;
            }
            if (accNo.charAt(i) == '0') {
               c += 1;
            }
         }
         if (c == 14) {
            return false;
         } else {
            return true;
         }
      } else {
         return false;
      }
   }
}

Dans le code ci-dessus, nous vérifions d'abord si le numéro de compte est nul ou vide, vérifions ensuite si la longueur du numéro de compte est de 14, puis vérifions si les caractères de la variable accNo sont des nombres ou non. Troisièmement, vérifiez s'il y a un zéro dans le nombre.

Maintenant, regardons les cas de tests unitaires utilisant JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid2(""));
      assertEquals(false, ob.isValid2("00000000000000"));
      assertEquals(true, ob.isValid2("67874864837684"));
      assertEquals(true, ob.isValid2("34324353488345"));
   }
}

Dans le code ci-dessus, nous vérifions 4 cas de tests unitaires différents pour vérifier le compte.

Méthode 3 : Utiliser un modèle d'expression régulière

Dans cette méthode, nous définissons un modèle d'expression régulière pour les nombres et vérifions les trois conditions nécessaires à la vérification du compte.

Exemple

import java.util.regex.Matcher;
import java.util.regex.Pattern;
  
public class BankingAccountNoServices {
   public boolean isValid3(String accNo) {
      if (accNo == null || accNo.equalsIgnoreCase("")) {
         return false; 
      }
      if (accNo.length() == 14) {
         int c = 0;
         String r = "[0-9]+"; 
         Pattern p = Pattern.compile(r);
         Matcher matcher = p.matcher(accNo);
         if (matcher.matches()) { 
            for (int i = 0; i < accNo.length(); i++) {
               if (accNo.charAt(i) == '0') {
                  c += 1;
               }
            }
            if (c == 14) { 
               return false;
            } else {
               return true;
            }
         } else {
            return false;
         }
      } else {
         return false;
      }
   }
}

Dans le code ci-dessus, nous vérifions d'abord si le numéro de compte est nul ou vide, deuxièmement vérifions si la longueur du numéro de compte est 14, puis définissons une expression régulière d'un nombre et vérifions les conditions nécessaires pour ces trois valeurs en utilisant les classes Pattern et Matcher.

Maintenant, regardons les cas de tests unitaires utilisant JUnit.

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test; 
public class TestBankingAccountNoServices {
   public void testForBankAccountNo() {
      BankingAccountNoServices ob = new BankingAccountNoServices();
      assertEquals(false, ob.isValid3("47283"));
      assertEquals(false, ob.isValid3("19037293284s32"));
      assertEquals(true, ob.isValid3("67874864837684"));
      assertEquals(true, ob.isValid3("34521678954632"));
   }
}

Dans le code ci-dessus, nous vérifions 4 cas de tests unitaires différents pour vérifier le compte.

Conclusion

Dans cet article, nous avons créé un projet Maven utilisant Junit spécifiquement pour vérifier les numéros de compte bancaire. Nous avons discuté de trois manières différentes d'écrire une logique métier qui valide les numéros de compte bancaire, à savoir en utilisant Long.parseLong, Character.isDigit() et en utilisant des modèles d'expressions régulières. N'importe lequel d'entre eux peut être utilisé pour effectuer une vérification des numéros de compte bancaire en Java.

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!