Mockito: como utilizar de maneira simples

#mockito #java #testing #test

Eu utilizo o Mockito tem algum tempo e é uma ferramenta muito poderosa. Sem ele criar testes seria muito mais verboso e de certa forma complicado.
Depois de entender bem o conceito e a forma de utilizar o desenvolvimento de testes fica muito mais rápido e assertivo.

O que é o Mockito?

O Mockito é um framework de Test and Spy e o seu principal objetivo é simular a instancia de classes e comportamento de métodos. Ao mockar uma dependência com o mockito, eu faço com que a classe que vai ser testada simule o método testado e suas dependências. Durante o mock eu posso configurar retorno e ações de acordo com o necessidade do teste.

Principais funções

Mock: cria uma instancia de uma classe, porém Mockada. Se você chamar um metodo ele não irá chamar o metodo real, a não ser que você queira.
Spy: cria uma instancia de uma classe, que você pode mockar ou chamar os metodos reais. É uma alternativa ao InjectMocks, quando é preciso mockar metodos da propria classe que esta sendo testada.
InjectMocks: criar uma intancia e injeta as dependências necessárias que estão anotadas com @Mock.
Verify: verifica a quantidade de vezes e quais parametros utilizados para acessar um determinado metodo.
When: Após um mock ser criado, você pode configurar ações na chamada e o retorno.
Matchers: permite a verificação por meio de matchers de argumentos (anyObject(), anyString() …)

Criando um mock

Há duas formas de criar um mock usando o mockito por meio de um método estático ou com a anotação @Mock

Utilizando método statico ```

var EmployeeRepository = Mockito.mock(EmployeeRepository.class)

* anotação @Mock

@Mock
private EmployeeRepository employeeRepository;

### Configurando a classe testada
Ao declarar a classe vamos anotar ela com @InjectMocks. O Mockito vai criar uma instância real dessa classe e injetar todos os objetos @ Mock que foram declarados na classe de teste.

@InjectMocks
private EmployeeController employeeController;

### Hibilitando as anotações
Para essas anotações @Mock e @InjectMocks funcionar, é preciso habilita-las. existem duas formas:
* Anotando a classe de teste com @RunWith(MockitoJUnitRunner.class)

@RunWith(MockitoJUnitRunner.class)
public class EmployeeControllerTest {}

* Usando o MockitoAnnotations.initMocks () antes dos testes

@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}


### Testando um metodo void
O método que vai ser testado:

@DeleteMapping("/employees/{id}")
public void deleteEmployee(@PathVariable Long id) {
repository.deleteById(id);
}

O teste

@test
public void deleteEmployee() {
employeeController.deleteEmployee(1L);
Mockito.verify(employeeRepository, Mockito.times(1)).deleteById(1L);
}

Primeiro chamamos o método que vai ser testado e passamos os 
parâmetros necessários.
Em seguida usamos o _Mockito.verify_ para verificar se durante a execução das classes mocadas foi chamado o método em questão.
Podemos verificar varias coisas com _Mockito.verify_ numero de vezes que executou, parâmetros recebidos e etc.

### @Spy Annotation
Usamos o @Spy para espionar uma instância existente.
No exemplo abaixo eu adicionei dois elementos a uma lista e em seguida verifiquei se os elementos foram mesmo inseridos.

@test
public void spyTest() {
List employees = Mockito.spy(new ArrayList());
Employee one = new Employee("Bilbo Baggins", "burglar");
Employee two = new Employee("Frodo Baggins", "thief");

    employees.add(one);
    employees.add(two);

    Mockito.verify(employees).add(one);
    Mockito.verify(employees).add(two);
    assertEquals(2, employees.size());

    Mockito.doReturn(100).when(employees).size();
    assertEquals(100, employees.size());
}

* employees.add() para adicionar elementos a employees.
* employees.size() para retornar 100 em vez de 2 usando Mockito.doReturn()

### Método when
Através dele é possível simular chamadas a recursos externos a classe, como acesso a um banco de dados por exemplo, sem se preocupar como funcionará essa consulta, não é responsabilidade desse teste.
A sintaxe do when é essa:
* when(employeeRepository.save(Mockito.any(Employee.class))).thenReturn(employee);
* when(employeeRepository.save(Mockito.eq(employeeInput))).thenReturn(employee);
* when(employeeRepository.save(Mockito.any())).thenReturn(employee);

@test
public void newEmployee_test() {
Employee employee = EmployeeTest.create();
when(employeeRepository.save(Mockito.any(Employee.class))).thenReturn(employee);
ResponseEntity newEmployee = employeeController.newEmployee(employee);
assertEquals(employee.getName(), newEmployee.getBody().getName());
assertEquals(employee.getRole(), newEmployee.getBody().getRole());
}


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mukdycphq9tqiv813dcy.png)

[Repo com mais exemplos](https://github.com/daienelima/exemplo-HATEOAS)