Ricerca…
Semplice finta
Mockito offre un mehtod di taglia unica per creare mock di classi e interfacce (non finali).
Dependency mock = Mockito.mock(Dependency.class);
Ciò crea un'istanza fittizia di Dependency indipendentemente dal fatto che Dependency sia un'interfaccia o una classe.
È quindi possibile interrompere le chiamate di metodo a tale simulazione utilizzando la notazione Mockito.when (x) .thenReturn (y).
Mockito.when(mock.possiblyBuggyMethod()).thenReturn("someString");
In questo modo, le chiamate a Dependency.possiblyBuggyMethod() restituiscono semplicemente "someString" .
C'è un'altra notazione che è scoraggiata nella maggior parte dei casi d'uso in quanto non è tipizzata.
Mockito.doReturn("someString").when(mock).possiblyBuggyMethod()
Mock con valori predefiniti
Mentre un semplice mock restituisce null (o valori predefiniti per i primitivi) a ogni chiamata, è possibile modificare tale comportamento.
Dependency mock = Mockito.mock(Dependency.class, new Answer() {
@Override
public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
return "someString";
}
});
o usando lambda:
Dependency mock = Mockito.mock(Dependency.class, (Answer) invocationOnMock -> "someString");
Questi esempi restituiscono "someString" ad ogni invocazione ma è possibile definire qualsiasi logica nel metodo di risposta.
Deridere una classe usando le annotazioni
Classe in prova:
public class GreetingsService { // class to be tested in isolation
private UserService userService;
public GreetingsService(UserService userService) {
this.userService = userService;
}
public String getGreetings(int userId, LocalTime time) { // the method under test
StringBuilder greetings = new StringBuilder();
String timeOfDay = getTimeOfDay(time.getHour());
greetings.append("Good ").append(timeOfDay).append(", ");
greetings.append(userService.getFirstName(userId)) // this call will be mocked
.append(" ")
.append(userService.getLastName(userId)) // this call will be mocked
.append("!");
return greetings.toString();
}
private String getTimeOfDay(int hour) { // private method doesn't need to be unit tested
if (hour >= 0 && hour < 12)
return "Morning";
else if (hour >= 12 && hour < 16)
return "Afternoon";
else if (hour >= 16 && hour < 21)
return "Evening";
else if (hour >= 21 && hour < 24)
return "Night";
else
return null;
}
}
Il comportamento di questa interfaccia verrà deriso:
public interface UserService {
String getFirstName(int userId);
String getLastName(int userId);
}
Assumere l'effettiva implementazione del UserService :
public class UserServiceImpl implements UserService {
@Override
public String getFirstName(int userId) {
String firstName = "";
// some logic to get user's first name goes here
// this could be anything like a call to another service,
// a database query, or a web service call
return firstName;
}
@Override
public String getLastName(int userId) {
String lastName = "";
// some logic to get user's last name goes here
// this could be anything like a call to another service,
// a database query, or a web service call
return lastName;
}
}
Test di Junit con Mockito:
public class GreetingsServiceTest {
@Mock
private UserServiceImpl userService; // this class will be mocked
@InjectMocks
private GreetingsService greetingsService = new GreetingsService(userService);
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetGreetings_morning() throws Exception {
// specify mocked behavior
when(userService.getFirstName(99)).thenReturn("John");
when(userService.getLastName(99)).thenReturn("Doe");
// invoke method under test
String greetings = greetingsService.getGreetings(99, LocalTime.of(0, 45));
Assert.assertEquals("Failed to get greetings!", "Good Morning, John Doe!", greetings);
}
@Test
public void testGetGreetings_afternoon() throws Exception {
// specify mocked behavior
when(userService.getFirstName(11)).thenReturn("Jane");
when(userService.getLastName(11)).thenReturn("Doe");
// invoke method under test
String greetings = greetingsService.getGreetings(11, LocalTime.of(13, 15));
Assert.assertEquals("Failed to get greetings!", "Good Afternoon, Jane Doe!", greetings);
}
}
"Spia" per beffa parziale
@Spy annotation (o method ) può essere usato per deridere parzialmente un oggetto. Ciò è utile quando si desidera simulare parzialmente il comportamento di una classe. Ad esempio, supponiamo di avere una classe che utilizza due servizi diversi e di voler prendere in giro solo uno di essi e utilizzare l'effettiva implementazione dell'altro servizio.
Nota a margine: anche se filosoficamente, non considererei questo un "puro test unitario" in un vero senso, poiché si sta integrando una vera classe e non testando la propria classe in prova in completo isolamento. Ciononostante, questo potrebbe essere effettivamente utile nel mondo reale e lo uso spesso quando faccio il mocking del database usando alcuni nell'implementazione del database di memoria, in modo da poter utilizzare veri DAO.
Class under test:
public class GreetingsService { // class to be tested in isolation
private UserService userService;
private AppService appService;
public GreetingsService(UserService userService, AppService appService) {
this.userService = userService;
this.appService = appService;
}
public String getGreetings(int userId, LocalTime time) { // the method under test
StringBuilder greetings = new StringBuilder();
String timeOfDay = getTimeOfDay(time.getHour());
greetings.append("Good ").append(timeOfDay).append(", ");
greetings.append(userService.getFirstName(userId)) // this call will be mocked
.append(" ")
.append(userService.getLastName(userId)) // this call will be mocked
.append("!");
greetings.append(" Welcome to ")
.append(appService.getAppName()) // actual method call will be made
.append(".");
return greetings.toString();
}
private String getTimeOfDay(int hour) { // private method doesn't need to be unit tested
if (hour >= 0 && hour < 12)
return "Morning";
else if (hour >= 12 && hour < 16)
return "Afternoon";
else if (hour >= 16 && hour < 21)
return "Evening";
else if (hour >= 21 && hour < 24)
return "Night";
else
return null;
}
}
Il comportamento di questa interfaccia verrà deriso:
public interface UserService {
String getFirstName(int userId);
String getLastName(int userId);
}
Assumere l'effettiva implementazione del UserService :
public class UserServiceImpl implements UserService {
@Override
public String getFirstName(int userId) {
String firstName = "";
// some logic to get user's first name
// this could be anything like a call to another service,
// a database query, or a web service call
return firstName;
}
@Override
public String getLastName(int userId) {
String lastName = "";
// some logic to get user's last name
// this could be anything like a call to another service,
// a database query, or a web service call
return lastName;
}
}
Il comportamento di questa interfaccia non verrà deriso:
public interface AppService {
String getAppName();
}
Assumi l'effettiva implementazione di AppService :
public class AppServiceImpl implements AppService {
@Override
public String getAppName() {
// assume you are reading this from properties file
String appName = "The Amazing Application";
return appName;
}
}
Test di Junit con Mockito:
public class GreetingsServiceTest {
@Mock
private UserServiceImpl userService; // this class will be mocked
@Spy
private AppServiceImpl appService; // this class WON'T be mocked
@InjectMocks
private GreetingsService greetingsService = new GreetingsService(userService, appService);
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
}
@Test
public void testGetGreetings_morning() throws Exception {
// specify mocked behavior
when(userService.getFirstName(99)).thenReturn("John");
when(userService.getLastName(99)).thenReturn("Doe");
// invoke method under test
String greetings = greetingsService.getGreetings(99, LocalTime.of(0, 45));
Assert.assertEquals("Failed to get greetings!", "Good Morning, John Doe! Welcome to The Amazing Application.", greetings);
}
@Test
public void testGetGreetings_afternoon() throws Exception {
// specify mocked behavior
when(userService.getFirstName(11)).thenReturn("Jane");
when(userService.getLastName(11)).thenReturn("Doe");
// invoke method under test
String greetings = greetingsService.getGreetings(11, LocalTime.of(13, 15));
Assert.assertEquals("Failed to get greetings!", "Good Afternoon, Jane Doe! Welcome to The Amazing Application.", greetings);
}
}
Imposta campi privati in oggetti derisi
Nella tua classe sottoposta a test, potresti avere alcuni campi privati che non sono accessibili nemmeno tramite il costruttore. In questi casi è possibile utilizzare la riflessione per impostare tali proprietà. Questo è un frammento di tale test JUnit.
@InjectMocks
private GreetingsService greetingsService = new GreetingsService(); // mocking this class
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
String someName = "Some Name";
ReflectionTestUtils.setField(greetingsService, // inject into this object
"name", // assign to this field
someName); // object to be injected
}
Sto usando di Sptring ReflectionTestUtils.setField(Object targetObject, String name, Object value) Metodo qui per semplificare, ma è possibile utilizzare Plain Old Java Reflection a fare lo stesso.