Le classi astratte vengono indicate come la classe dichiarata con la parola chiave abstract che può includere o meno i metodi astratti. In Java, le classi astratte non possono essere istanziate, ma possono essere sottoclassate. Può anche avere campi statici e metodi statici.
In questa sezione discuteremo della derisione o dello spionaggio delle classi astratte. Analizzeremo diversi casi di test delle classi astratte utilizzando metodi non astratti.
Per spiare o deridere le classi astratte, dobbiamo aggiungere le seguenti dipendenze Maven:
- JUnit
- Mockito
- PowerMock
Tutte le dipendenze richieste del progetto sono riportate di seguito:
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
Le dipendenze PowerMock sono necessarie solo per il test in cui utilizziamo PowerMock.
Esempi di classe astratta beffarda
1. Classe astratta di spionaggio utilizzando Mockito.spy()
In questo esempio, spieremo le classi astratte utilizzando il metodo Mockito.spy(). Il metodo Mockito.spy() viene utilizzato per creare un'istanza spia della classe astratta.
Passo 1: Crea una classe astratta denominata Abstract1_class che contenga metodi astratti e non astratti.
Abstract1_class.java
public abstract class Abstract1_class { public abstract int newAbstractmethod(); public String methodUnderTest() { return 'one' ; } } Passo 2: Crea un test case JUnit denominato Estratto1Test . Contiene un'istanza spia della classe astratta.
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); } } Produzione
L'output seguente mostra che il test è in esecuzione con successo.
Lo svantaggio dell'utilizzo del metodo Mockito.spy() è che invocherà il costruttore della classe astratta durante la creazione dell'istanza spia. Nella maggior parte dei casi, il costruttore utilizza dipendenze esterne che possono rappresentare un ostacolo alle esecuzioni dei nostri test unitari. Queste dipendenze esterne sono generalmente note come file impedimenti alla prova . È il motivo per utilizzare il metodo Mockito.mock() per deridere le classi astratte.
2. Classe astratta beffarda utilizzando Mockito.mock()
In questo esempio, derideremo le classi astratte utilizzando il metodo Mockito.mock().
tutorial sulla scintilla
Di solito, il mocking viene utilizzato per creare un clone o un oggetto fittizio della classe. In altre parole, rende vacante una classe dalla sua logica o dai suoi algoritmi. L'istanza fittizia creata non contiene codice (logica) all'interno dei metodi.
Passo 1: Crea una classe astratta denominata Abstract_Class che contenga metodi sia astratti che non astratti.
Abstract_Class.java
public abstract class Abstract_Class { public String sayMock() { return 'Hii.. ' + getName() + symbol() ; } private String symbol() { return '!!'; } protected abstract String getName(); } Passo 2: Crea un test case JUnit denominato AbstractTestClass per aver deriso la classe astratta.
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()); } } Nel codice sopra, E è un'istanza simulata creata utilizzando il metodo Mockito.mock().
Produzione
L'output seguente mostra che il test viene eseguito correttamente utilizzando Mockito.
L'approccio di cui sopra non è il migliore, ma può essere utilizzato. L'approccio successivo è consigliato perché utilizza PowerMock e può avere il controllo sui metodi privati definiti nelle classi astratte.
3. Simulazione di una classe astratta utilizzando PowerMock
Nell'esempio seguente, utilizzeremo il metodo PowerMockito.mock() per deridere le classi astratte. Usare PowerMock invece di Mockito.mock() è un approccio migliore in quanto può avere il controllo sui metodi privati e statici.
Passo 1: Crea una classe astratta denominata Classe_astratta che contiene sia metodi astratti che non astratti.
Abstract_class.java
public abstract class Abstract_Class { public abstract int myAbstractMethod(); public String sayMock() { return getName() + '13' ; } private String getName() { return 'Jyotika'; } } Passo 2: Crea un test case JUnit denominato AbstractTestClass a scopo di test.
AbstractTestClass.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); } } Produzione
L'output seguente mostra che il test viene eseguito correttamente utilizzando PowerMock con Mockito.
