Les classes abstraites sont appelées classes déclarées avec le mot-clé abstract qui peut ou non inclure les méthodes abstraites. En Java, les classes abstraites ne peuvent pas être instanciées, mais elles peuvent être sous-classées. Il peut également avoir des champs statiques et des méthodes statiques.
fmovies inde
Dans cette section, nous discuterons de la moquerie ou de l’espionnage des classes abstraites. Nous analyserons plusieurs cas de tests de classes abstraites utilisant des méthodes non abstraites.
Pour espionner ou se moquer des classes abstraites, nous devons ajouter les dépendances Maven suivantes :
- JUnit
- Mockito
- PowerMock
Toutes les dépendances requises du projet sont indiquées ci-dessous :
junit junit 4.12 test org.mockito mockito-all 1.10.19 test org.powermock powermock-module-junit4 1.7.4 test org.powermock powermock-api-mockito 1.7.0 test
Les dépendances PowerMock ne sont requises que pour le test dans lequel nous utilisons PowerMock.
Exemples de classe abstraite moqueuse
1. Classe abstraite d'espionnage à l'aide de Mockito.spy()
Dans cet exemple, nous allons espionner les classes abstraites en utilisant la méthode Mockito.spy(). La méthode Mockito.spy() est utilisée pour créer une instance d'espionnage de la classe abstraite.
Étape 1: Créez une classe abstraite nommée Abstract1_class qui contient à la fois des méthodes abstraites et non abstraites.
Abstract1_class.java
public abstract class Abstract1_class { public abstract int newAbstractmethod(); public String methodUnderTest() { return 'one' ; } } Étape 2: Créez un scénario de test JUnit nommé Résumé1Test . Il contient une instance espion de la classe abstraite.
listes Java
Abstract1Test.java
import static org.junit.Assert.*; import org.junit.Test; import org.mockito.Mockito; import junit.framework.Assert; public class Abstract1Test { @Test public void testing_usingSpy() { Abstract1_class abstclas = Mockito.spy(Abstract1_class.class); String res = abstclas.methodUnderTest(); Assert.assertEquals('one', res); } } Sortir
Le résultat suivant montre que le test s’exécute avec succès.
L'inconvénient de l'utilisation de la méthode Mockito.spy() est qu'elle invoquera le constructeur de classe abstraite lors de la création de l'instance d'espionnage. Dans la plupart des cas, le constructeur utilise des dépendances externes qui peuvent constituer un frein à nos exécutions de tests unitaires. Ces dépendances externes sont généralement appelées tester les obstacles . C'est la raison pour laquelle il faut utiliser la méthode Mockito.mock() pour se moquer des classes abstraites.
2. Classe abstraite moqueuse utilisant Mockito.mock()
Dans cet exemple, nous allons nous moquer des classes abstraites en utilisant la méthode Mockito.mock().
Habituellement, la moquerie est utilisée pour créer un objet clone ou factice de la classe. En d’autres termes, cela rend une classe vacante par rapport à sa logique ou à ses algorithmes. L'instance fictive créée ne contient pas de code (logique) à l'intérieur des méthodes.
Étape 1: Créez une classe abstraite nommée Abstract_Class qui contient à la fois des méthodes abstraites et non abstraites.
chaîne en jsonobject
Abstract_Class.java
public abstract class Abstract_Class { public String sayMock() { return 'Hii.. ' + getName() + symbol() ; } private String symbol() { return '!!'; } protected abstract String getName(); } Étape 2: Créez un scénario de test JUnit nommé Classe de test abstraite pour se moquer de la classe abstraite.
AbstractTestClass.java
import static org.junit.Assert.*; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Test; public class AbstractTestClass { @Test public void test_AbstractClasses() { Abstract_Class ac = mock(Abstract_Class.class); when(ac.sayMock()).thenCallRealMethod(); when(ac.getName()).thenReturn('Jyotika'); assertEquals('Hii.. Jyotika!!', ac.sayMock()); } } Dans le code ci-dessus, et est une instance simulée créée à l'aide de la méthode Mockito.mock().
Sortir
lire le fichier csv en java
Le résultat suivant montre que le test s'exécute avec succès à l'aide de Mockito.
L’approche ci-dessus n’est pas la meilleure, mais elle peut être utilisée. L'approche suivante est recommandée car elle utilise PowerMock et peut contrôler les méthodes privées définies dans les classes abstraites.
3. Classe abstraite moqueuse à l'aide de PowerMock
Dans l'exemple suivant, nous utiliserons la méthode PowerMockito.mock() pour nous moquer des classes abstraites. Utiliser PowerMock au lieu de Mockito.mock() est une meilleure approche car elle peut contrôler les méthodes privées et statiques.
Étape 1: Créez une classe abstraite nommée Classe_abstraite qui contient à la fois des méthodes abstraites et non abstraites.
Abstract_class.java
public abstract class Abstract_Class { public abstract int myAbstractMethod(); public String sayMock() { return getName() + '13' ; } private String getName() { return 'Jyotika'; } } Étape 2: Créez un scénario de test JUnit nommé Classe de test abstraite à des fins de tests.
AbstractTestClass.java
oups concept en java
import static org.junit.Assert.*; import org.junit.Test; import org.junit.runner.RunWith; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @RunWith(PowerMockRunner.class) @PrepareForTest( Abstract_Class.class) public class AbstractTestClass { @Test public void test_AbstractClassesusing_PowerMock() throws Exception { // given Abstract_Class ac = PowerMockito.mock(Abstract_Class.class); PowerMockito.doCallRealMethod().when(ac).sayMock(); PowerMockito.doReturn('Sharma').when(ac , 'getName'); //when String newstring = ac.sayMock(); //then assertEquals('Sharma13', newstring); System.out.println(newstring); } } Sortir
Le résultat suivant montre que le test s'exécute avec succès à l'aide de PowerMock avec Mockito.
