Java >> Tutoriel Java >  >> Tag >> JUnit

Exemple de maquette JUnit

JUnit

1. Présentation

Les méthodes et les façons de créer des cas de test unitaire ont évolué depuis son introduction. De nouveaux outils et API sont désormais disponibles et fournissent un schéma plus avancé de création et d'exécution de cas de test JUnit. Les services sont devenus plus incubés, de sorte que la création de cas de test d'intégration est une tâche ardue pour tout développeur.

L'introduction de cette nouvelle approche de développement a également apporté des changements révolutionnaires dans les tests unitaires et de nombreux frameworks de test sont venus élever le niveau sur le terrain de jeu. Avec cela, la nécessité de créer des objets factices pour imiter les objets Java dans leur exécution n'a jamais été aussi importante, en particulier sur les logiciels d'entreprise critiques.

Dans cet article, je vais montrer l'un des frameworks JUnit Testing Mocking les plus utilisés et les plus populaires - Mockito.

2. Cadre Mockito

Mockito est l'une des API de test les plus utilisées pour Java. Des tonnes d'exemples sont acceptés par l'immense communauté Java. En 2008, Dan North a déclaré qu'il s'agissait du futur modèle de test des applications Java. La popularité de Mockito et l'ensemble des projets Java dans Github qui utilisent cette API indiquent clairement que la prédiction était vraie.

3. Exemple d'éclipse

Plongeons en profondeur dans un exemple. Dans cet exemple, nous allons créer ce qui suit :

  • Créer un nouveau projet Maven
  • Définissez les dépendances dont nous avons besoin. C'est JUnit et Mockito
  • Codez quelques exemples

3.1 Projet Maven

Commençons par créer un nouveau projet Maven. Dans votre éclipse, cliquez sur File> New Project> Maven Project. Cochez sur créer un projet simple remplissez l'identifiant du groupe, l'identifiant de l'artefact et appuyez sur Terminer.

Figure 1.0 Projet Maven

3.2 Configuration de pom.xml

Nous incluons ensuite les dépendances dont nous avons besoin. Cela téléchargera les bibliothèques pour notre projet.

pom.xml 

<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.jgc.areyes.junit</groupId>
	<artifactId>junit-mockito-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
		</dependency>
		<dependency>
			<groupId>org.mockito</groupId>
			<artifactId>mockito-all</artifactId>
			<version>1.9.5</version>
		</dependency>
	</dependencies>
</project>

3.3 Exemple de cas de test

JUnitServiceTestExample.java 

package com.areyes1.jgc.mockito.e;

import static org.mockito.Mockito.*;
import static org.junit.Assert.*;

import java.util.Iterator;

import org.junit.Test;
import org.mockito.Matchers;
import org.mockito.Mockito;

/**
 * The Class JUnitServiceTestExample.
 */
public class JUnitServiceTestExample {

	/**
	 * Test1.
	 */
	@Test
	public void testSimpleInt() {
		// create mock
		TestService test = Mockito.mock(TestService.class);

		// define return value for method getUniqueId()
		when(test.getUniqueId()).thenReturn(43);

		// use mock in test....
		assertEquals(test.getUniqueId(), 43);
	}

	/**
	 * Test more than one return value.
	 */
	// Demonstrates the return of multiple values
	@Test
	public void testMoreThanOneReturnValue() {
		Iterator i = mock(Iterator.class);
		when(i.next()).thenReturn("Mockito").thenReturn("is neat!!");
		String result = i.next() + " " + i.next();
		assertEquals("Mockito is neat!!", result);
	}

	/**
	 * Test return value dependent on method parameter.
	 */
	@Test
	public void testReturnValueDependentOnMethodParameter() {
		Comparable c = mock(Comparable.class);
		when(c.compareTo("Mockito")).thenReturn(1);
		when(c.compareTo("Eclipse")).thenReturn(2);
		// assert
		assertEquals(1, c.compareTo("Mockito"));
	}

	/**
	 * Test return value in dependent on method parameter.
	 */
	@Test
	public void testReturnValueInDependentOnMethodParameter() {
		Comparable c = mock(Comparable.class);
		when(c.compareTo(anyInt())).thenReturn(-1);
		assertEquals(-1, c.compareTo(9));
	}

	@Test
	public void testVerify() {
		// create and configure mock
		TestService test = Mockito.mock(TestService.class);
		when(test.getUniqueId()).thenReturn(43);

		// call method testing on the mock with parameter 12
		test.testing(12);
		test.getUniqueId();
		test.getUniqueId();
		test.someMethod("Hello World");
		test.someMethod("called at least once");
		test.someMethod("called at least twice");
		test.someMethod("called five times");
		test.someMethod("called at most 3 times");

		// now check if method testing was called with the parameter 12
		verify(test).testing(Matchers.eq(12));

		// was the method called twice?
		verify(test, times(2)).getUniqueId();

		// other alternatives for verifiying the number of method calls for a
		// method
		verify(test, never()).someMethod("never called");
		verify(test, atLeastOnce()).someMethod("called at least once");
		
		//	Will all fail because we didn't met the conditions.
		verify(test, atLeast(2)).someMethod("called at least twice");	 
		verify(test, times(5)).someMethod("called five times");
		verify(test, atMost(3)).someMethod("called at most 3 times");
	}

}

L'exemple ci-dessus présente les différentes utilisations uniques de Mockito. En plus de se moquer des objets, il complète également parfaitement ce que nous appelons les cas de test « pilotés par le comportement ». Cela signifie que le cas de test vise à tester le comportement ou tout appel de méthode dans les services en dehors de la sortie elle-même.

Passons en revue chaque méthode :

  • testSimpleInt – le cas de test crée une classe fictive et appelle la méthode. Il applique la méthode à utiliser 43 comme retour. Ceci est ensuite testé via un assertEquals méthode comme indiqué.
  • testMoreThanOneReturnValue – les cas se sont moqués d'une classe d'itérateur et définissent une nouvelle valeur pour le premier enregistrement. L'exemple montré concatène deux nouvelles chaînes sur le 1er élément. Cet enregistrement est ensuite testé via un assertEquals méthode.
  • testReturnValueInDependentOnMethodParameter – Le cas de test montre comment nous pouvons utiliser dynamiquement d'autres résultats même dans notre logique de comparaison. Dans cet exemple, nous avons forcé les comparaisons à retourner des valeurs qui sont ensuite testées via un assertEquals méthode.
  • testVerify – le cas de test montre comment nous pouvons tester le comportement d'une méthode au sein de la classe. Il teste le nombre d'appels effectués à la méthode et s'il y a des changements dans les types de retour. Il s'agit d'une fonctionnalité puissante, car elle permet non seulement aux développeurs de tester les résultats, mais également de tester le comportement d'un service spécifique.

Mockito a redéfini la création de cas de test. Presque tous les projets dans le monde utilisent l'API. Il ne s'agit pas seulement de se moquer des objets et des classes, mais aussi de créer un lieu permettant aux développeurs de développer des cas de test plus concrets et à l'épreuve des balles qui garantissent la stabilité du logiciel.

4 Sortie

L'exécution du cas de test ci-dessus donnera la sortie ci-dessous.

Figure 2.0 Sortie des cas de test Mockito

5. Télécharger le projet Eclipse

Ceci était un exemple de JUnit Mockito.junit mockito

Balise Java