[JAVA] Comment utiliser JUnit (débutant)
À propos de l'utilisation de JUnit. JUnit est une version plus ancienne car elle est écrite pour diffuser le code de test sur le lieu de travail.
introduction
Pourquoi voulez-vous introduire l'habitude d'écrire des tests
- Je veux créer un environnement où le refactoring peut être fait facilement
- Je veux détecter une dégradation
- Je souhaite augmenter la vitesse de développement (y compris la vitesse de test)
- Je souhaite réduire le fardeau des évaluateurs
Je ne pense pas que ce sera efficace dès que je commencerai à écrire du code de test, mais j'espère l'améliorer petit à petit. Quand j'écris le code de test, je pense que l'histoire se présente sous la forme de "main-d'oeuvre ..." ou de "vitesse ...", mais cela prend du temps avant de m'y habituer, et si je commence réellement à l'écrire, je reviendrai en arrière. Je pense qu'il y a beaucoup de bonnes choses dans son ensemble parce que la qualité est facile à améliorer parce que je teste par rapport à mon propre code.
Il existe différents articles sur l'utilité du code de test, veuillez donc y jeter un œil.
référence
L'histoire de l'introduction de tests dans des zones sans loi où il n'y avait pas de tests et l'augmentation de la vitesse de développement de 1,7 fois Comment lutter contre la dette technique
Alors jusqu'où visez-vous
J'aimerais discuter de ce domaine de différentes manières, mais personnellement, je n'ai pas encore visé 90% ou plus de couverture, je vais donc en faire une habitude pour le moment et préparer la future migration du cadre. Je pense.
C'est ce que je veux faire dans un proche avenir.
-
Test automatique avec CI Je veux écrire un code de test et le revoir, pas la fin (prévention du dégraissage)
-
Visualisation du taux de couverture Je veux visualiser les efforts de l'équipe et garder la motivation
-
Revue du système de développement (objectif de la revue, etc.) Si vous écrivez du code de test, le but de la révision du code changera naturellement, donc j'aimerais le revoir. De plus, il peut être nécessaire de répartir les rôles avec l'équipe d'assurance qualité.
Environnement d'exécution
- Java 1.8
- JUnit 4.4
Échantillon de test simple
Pour vous donner une idée approximative du test, voici un exemple de test simple.
Code de production
public class HelloJunit {
public String sayHello() {
return "Hello";
}
}
Code de test
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import org.junit.Test;
public class HelloJunitTest {
@Test
dire public void Bonjour() {
HelloJunit helloJunit = new HelloJunit();
assertThat(helloJunit.sayHello(), is("Hello"));
}
}
Explication du code de test
nom de la classe
Pour le nom de la classe de test, définissez le nom obtenu en ajoutant Test au nom de classe du code de production à tester. Cela reconnaîtra la classe testée et le code de test comme une paire de test.
Méthode d'essai
Créez une méthode de test. Pour les tests, créez une méthode par cas si possible. (Ne créez pas plusieurs tests dans la même méthode) En outre, définissez le nom de la méthode en japonais afin que le contenu du scénario de test puisse être facilement compris.
En ajoutant l'annotation @ Test à la méthode, elle sera exécutée en tant que méthode cible du test lorsque le test sera exécuté.
assertThat / is
Utilisez ʻassertThatlors de la comparaison des valeurs. L'utilisation de assertThat est ʻassertThat (valeur attendue, méthode Matcher (valeur mesurée));.
La méthode ʻis effectue une comparaison en utilisant les ʻequals de l'objet cible.
Cette fois, les chaînes "Hello" sont comparées et vraies, le test est donc réussi.
Résultat d'exécution
Si le graphique de droite est vert, vous avez réussi. Pour plus de détails, vérifiez l'exécution, l'erreur et l'échec sur la gauche.
Si ça échoue
Si le test échoue, les détails de l'erreur seront affichés dans le journal. (Le graphique de droite devient rouge) Un résultat de comparaison concret (valeur) est affiché dans la trace des échecs, il est donc nécessaire de le corriger en se référant à cela.
Annotation
Test Il s'agit d'une annotation que JUnit doit reconnaître comme méthode de test. Si cette annotation est jointe, elle sera testée. La méthode doit être «public void».
Annotation de test
@Test
dire public void Bonjour() {
helloJunit = new HelloJunit();
assertThat(helloJunit.sayHello(), is("Hello"));
}
Before Les méthodes avec cette annotation sont exécutées avant d'exécuter le test. Il est utilisé pour effectuer un traitement courant.
Dans l'exemple suivant, le processus d'instanciation de la classe cible de test couramment utilisée est inclus.
Avant l'annotation
@Before
public void setUp() {
helloJunit = new HelloJunit();
}
After La méthode avec cette annotation sera exécutée en dernier après tous les tests. Il existe une méthode d'utilisation telle que l'allocation d'une ressource externe avec Before et sa libération avec After.
Après l'annotation
@Before
public void setUp() {
helloJunit = new HelloJunit();
File file = new File(FILE_PATH);
try {
filereader = new FileReader(file);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
@After
public void termDown() {
try {
filereader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
Ignore Les méthodes avec cette annotation seront ignorées même avec l'annotation Test. Il est utilisé lorsque vous ne souhaitez pas effectuer de test temporairement pour une raison quelconque.
@Ignore
@Test
dire public void Bonjour() {
helloJunit = new HelloJunit();
assertThat(helloJunit.sayHello(), is("Hello"));
}
Matcher API
is Il est comparé en utilisant la méthode égale. Si vous définissez un type primitif, il sera changé en classe wrapper et comparé à equals.
is
@Test
Essayer public void est() {
assertThat("Hello", is("Hello"));
assertThat(1, is(1));
}
not
not est un test pour s'assurer que le résultat de la comparaison est faux.
Vous pouvez utiliser ʻassertThat ("Hello", pas ("bye")); , mais il vaut mieux utiliser ʻis (not (~)) pour qu'il soit correct en anglais.
not
@Test
Essayez public void not() {
assertThat("Hello", is(not("bye")));
}
null value Assurez-vous qu'il est nul. Inversement, il existe également «notNullValue».
nullValue
@Test
essayez public void nullValue() {
assertThat(null, nullValue());
}
instanceOf(isA) Assurez-vous que les types sont les mêmes.
- Remarque: dans les versions plus récentes de JUnit, vous pouvez le remplacer par ʻisA`. *
instanceOf
@Test
Essayez public void instanceOf() {
assertThat("Hello", instanceOf(String.class));
}
sameInstance Assurez-vous qu'il s'agit de la même instance.
sameInstance
@Test
Essayez public void sameInstance() {
assertThat("Hello", sameInstance("Hello"));
}
allOf Si tous les Matchers dans allOf sont vrais, cela réussira.
allOf
@Test
Essayez public void allOf() {
assertThat("Hello", allOf(not("bye"),sameInstance("Hello")));
}
Autre
Si la version de JUnit est un peu plus élevée, il existe des versions utiles telles que hasItem, hasItems et startsWith, mais ...
Pour plus d'informations, veuillez consulter ici.
Vérifier les exceptions
C'est un moyen de tester qu'une exception est sortie. Il existe deux façons de tester.
- Définir la cible dans l'annotation Test
- Essayez attraper et vérifier
Voici un exemple de code de production.
Code de production
public class HelloJunit {
public void throwException() {
throw new IllegalArgumentException("Argument invalide");
}
}
Vérifier avec l'annotation de test
Vous pouvez tester en utilisant «attendu» dans l'annotation Test et en spécifiant la classe dans laquelle l'exception se produit.
Vérifier avec l'annotation de test
@Test(expected = IllegalArgumentException.class)
Vérifier l'exception de void public avec l'annotation Test() {
helloJunit.throwException();
}
Attraper et vérifier
Vous pouvez comparer le code sous test par try catch.
Avec cette méthode, il est possible de vérifier le message lorsqu'une exception se produit.
- Remarque: dans les versions plus récentes de JUnit, vous pouvez le remplacer par une
annotation de règle. *
attraper et vérifier
@Test
Vérifier l'exception de void public avec catch() {
try {
helloJunit.throwException();
} catch (IllegalArgumentException expected) {
assertThat(expected.getMessage(), is("Argument invalide"));
}
}
Matériel de référence
- Assert Javadoc
- Hamcrest Javadoc
- Introduction à la pratique JUnit Shuji Watanabe, Technical Review Co., Ltd.
Autres articles Qiita qui ont l'air bien [Notes sur l'utilisation des méthodes définies dans les Matchers de Hamcrest](https://qiita.com/opengl-8080/items/e57dab6e1fa5940850a3#isin-- Vérifiez qu'il correspond à l'élément spécifié dans le tableau ou dans la collection À)
Recommended Posts