DEV Community: pedro-henrique-arruzzo

TDD and tests with Mocks

pedro-henrique-arruzzo — Mon, 28 Jun 2021 13:47:24 +0000

TDD

Test Driven Development is a way of developing your code where the test is created before the actual code. This is made to make sure that the development works. The test must be the first thing to be created so the code can be created around it.

A good way to make these tests is using Mockito.

Mockito

Mockito is a mocking framework that is frequently used in unit tests. Mocking an object simulates it's behavior. When this simulation is created, it makes possible to realize a test without the need to call a complex object, we call only the mocked object.

Exemples

It's necessary to initiate the mocks before the tests.

@Before
public void setup(){
    service = new RentService();
    RentDAO dao = Mockito.mock(RentDAO.class);
    service.setRentDao(dao);
    spcService = Mockito.mock(SPCService.class);
    service.setSpcService(spcService);
}

I'm simulating the interfaces RentDAO and SPCService with Mockito.

RentDAO: public void save(Rent rent);
SPCService: public boolean isNegative(User user);

With this we can make our test calling the mock.

@Test
public void rentTest() throws Exception {
    //given
    User user = UserBuilder.aUser().now();
    List<Movie> movies = Arrays.asList(MovieBuilder.aMovie().withValue(5.0).now());

    //when
    Rent rent = service.rentMovie(user, movies);

    //then
    error.checkThat(rent.getValue(), is(equalTo(5.0)));
    error.checkThat(DataUtils.isSameDate(rent.getRentDate(), new Date()), is(true));
    error.checkThat(DataUtils.isSameDate(rent.getReturnDate(), DataUtils.obtainDataInDifferenceInDays(1)), is(true));
}

In this test, a user and a movie where initiated and the rent service was mocked.

Conclusion

This way, it's possible to test if the rent service works without actually using it. That's useful to avoid, for example, unnecessary calls to the data base, just mock the object that make this call.

In case you are interested, here's the repository on GitHub, with more of these mocked tests: https://github.com/pedro-henrique-arruzzo/poc/tree/main/MockTests

TDD e testes com Mocks

pedro-henrique-arruzzo — Fri, 25 Jun 2021 17:55:45 +0000

TDD

Test Driven Development é uma maneira de desenvolver o seu código onde o teste é criado antes da alteração/criação do código. Isso é feito para que o desenvolvimento tenha a garantia de sua funcionalidade.

O teste deve ser a primeira coisa a ser feita para que o código seja desenvolvido em volta desse teste para que, ao final do desenvolvimento, o mesmo esteja funcionando, provando que o código funciona.

Uma boa maneira de realizar estes testes é utilizando o Mockito.

Mockito

Mockito é um framework de mocking que é frequentemente usado em
testes de unidade. Mockar um objeto é simular o seu comportamento. Ao criar esta simulação, fica possível realizar um teste sem precisar chamar um objeto complexo, chamamos apenas o mock.

Exemplos

É necessário iniciar os mocks antes dos testes.

@Before
public void setup(){
    service = new RentService();
    RentDAO dao = Mockito.mock(RentDAO.class);
    service.setRentDao(dao);
    spcService = Mockito.mock(SPCService.class);
    service.setSpcService(spcService);
}

Estou simulando as interfaces RentDAO e SPCService com o Mockito.

RentDAO: public void save(Rent rent);
SPCService: public boolean isNegative(User user);

Com isso podemos realizar o teste chamando o mock.

@Test
public void rentTest() throws Exception {
    //given
    User user = UserBuilder.aUser().now();
    List<Movie> movies = Arrays.asList(MovieBuilder.aMovie().withValue(5.0).now());

    //when
    Rent rent = service.rentMovie(user, movies);

    //then
    error.checkThat(rent.getValue(), is(equalTo(5.0)));
    error.checkThat(DataUtils.isSameDate(rent.getRentDate(), new Date()), is(true));
    error.checkThat(DataUtils.isSameDate(rent.getReturnDate(), DataUtils.obtainDataInDifferenceInDays(1)), is(true));
}

Neste teste, um usuário e um filme foram iniciados e o serviço de locação foi mockado.

Conclusão

Desta maneira, é possível testar se o serviço de locação funciona sem fazer, de fato, uma locação.
Isso é útil para evitar, por exemplo, idas desnecessárias ao banco de dados, basta mockar o objeto que faz a chamada.

Caso esteja interessado, aqui está o repositório no GitHub com mais testes mockados: https://github.com/pedro-henrique-arruzzo/poc/tree/main/MockTests

Unit Tests with JUnit

pedro-henrique-arruzzo — Wed, 16 Jun 2021 12:27:55 +0000

Unitary tests are extremely necessary in any application to guarantee its functionality during the development. This tests must be done in a simple and fast way, so they can bem executed many times without taking a long time. Also, they must be independent, which means that one test shouldn't affect the results of another. And they should be repeatable.
These tests must reach to every scenery possible that the application will be used.

For example, your application offers a service of movie renting. Your tests must simulate this service in many different situations, like, changing quantities, prices, etc.

Now lets talk a little about JUnit, which is the main tool for the execution of unitary tests.

JUnit is an extremely important framework, because, with him, we can create tests to verify the functionality of classes and its methods. Besides that, he is responsible for the execution of these tests. This way, every time that the code has been changed, these tests can be executed to guarantee the integrity of the application.

Example:

I made a simple code of a movie renting service, and i want to make a test.

Three entities were created: Movie, Renting and User.

Here's the RentingService:

public class RentService {

    public Rent rentMovie(User user, List<Movie> movies)
            throws FilmeSemEstoqueException, LocadoraException {
        if(user == null) {
            throw new LocadoraException("Empty user");
        }

        if(movies == null || movies.isEmpty()) {
            throw new LocadoraException("Empty movie");
        }

        for (Movie movie : movies) {
            if (movie.getStock() == 0) {
                throw new FilmeSemEstoqueException();
            }
        }

        Rent rent = new Rent();
        rent.setMovies(movies);
        rent.setUser(user);
        rent.setRentDate(new Date());
        Double totalValue = 0d;
        for (Movie movie : movies){
            totalValue += movie.getRentPrice();
        }
        rent.setValue(totalValue);

        //Next day return
        Date returnDate = new Date();
        returnDate = adicionarDias(returnDate, 1);
        rent.setReturnDate(returnDate);

        //Salvando a locacao... 
        //TODO adicionar método para salvar

        return rent;
    }
}

Now with the entities and the service created we can make the tests.

@Test
    public void rentTest() throws Exception {
        //given
        User user = new User("User 1");
        List<Movie> movies = Arrays.asList(new Movie("Movie 1", 1, 5.0));

        //when
        Rent rent = service.rentMovie(user, movies);

        //then
        error.checkThat(rent.getValue(), is(equalTo(5.0)));
        error.checkThat(isMesmaData(rent.getRentDate(), new Date()), is(true));
        error.checkThat(isMesmaData(rent.getReturnDate(), obterDataComDiferencaDias(1)), is(true));
    }

First, we must create the scenery of the test, initializing the entities and giving them a value, we call this "Given".

User user = new User("User 1");
List<Movie> movies = Arrays.asList(new Movie("Movie 1", 1, 5.0));

With the "Given" created, we'll make the action we want to test, in this case, rent a movie, we call this "When".

Rent rent = service.rentMovie(user, movies);

At last, it's necessary that we verify if everything is working, we call this "Then".

error.checkThat(rent.getValue(), is(equalTo(5.0))); error.checkThat(isMesmaData(rent.getRentDate(), new Date()), is(true)); error.checkThat(isMesmaData(rent.getReturnDate(), obterDataComDiferencaDias(1)), is(true));

Conclusion

With this, it's possible to create tests in different scenarios and make sure your application won't break with an alteration on the code.

If anyone is interested, the code is on GitHub

Testes Unitários com JUnit

pedro-henrique-arruzzo — Wed, 16 Jun 2021 12:27:10 +0000

Testes são extremamente necessários em qualquer aplicação para garantir sua funcionalidade durante seu desenvolvimento. Esses testes devem ser feitos de forma simples e rápida, para que possam ser executados várias vezes sem levar muito tempo. Além disso, devem ser independentes, ou seja, um teste não deve afetar o outro. E também, deve ser possível repeti-los sempre que for preciso.
Estes testes devem abranger todos os cenários possíveis que a aplicação será usada.

Por exemplo, sua aplicação oferece um serviço de locação de filmes. Seus testes devem simular este serviço em diversas situações diferentes, ou seja, com diferentes quantidades de produtos, preços diferentes e etc.

Agora vamos falar um pouco sobre o JUnit, que é a principal ferramenta para a execução de testes unitários.

JUnit é um framework extremamente importante, pois, com ele, podemos criar testes para verificar funcionalidades de classes e seus métodos. Além disso, ele é responsável por automatizar a execução destes testes. Desta maneira, sempre que houver alguma alteração no código, os testes serão executados para garantir a integridade da aplicação.

Exemplo:

Criei um código simples de um serviço de locação de filmes, e quero realizar um teste.

Três entidades foram criadas: Filme, Locacao, e Usuario.

LocacaoService:

    public Locacao alugarFilme(Usuario usuario, List<Filme> filmes) 
            throws FilmeSemEstoqueException, LocadoraException {
        if(usuario == null) {
            throw new LocadoraException("Usuario vazio");
        }

        if(filmes == null || filmes.isEmpty()) {
            throw new LocadoraException("Filme vazio");
        }

        for (Filme filme: filmes) {
            if (filme.getEstoque() == 0) {
                throw new FilmeSemEstoqueException();
            }
        }

        Locacao locacao = new Locacao();
        locacao.setFilmes(filmes);
        locacao.setUsuario(usuario);
        locacao.setDataLocacao(new Date());
        Double valorTotal = 0d;
        for (Filme filme:filmes){
            valorTotal += filme.getPrecoLocacao();
        }
        locacao.setValor(valorTotal);

        //Entrega no dia seguinte
        Date dataEntrega = new Date();
        dataEntrega = adicionarDias(dataEntrega, 1);
        locacao.setDataRetorno(dataEntrega);

        return locacao;
    }

Agora com as entidades e os serviços criados podemos fazer os testes.

@Test
public void testeLocacao() throws Exception {
    //given
    Usuario usuario = new Usuario("Usuario 1");
    List<Filme> filmes = Arrays.asList(new Filme("Filme 1", 1, 5.0));

    //when
    Locacao locacao = service.alugarFilme(usuario, filmes);

    //then
    error.checkThat(locacao.getValor(), is(equalTo(5.0)));
    error.checkThat(isMesmaData(locacao.getDataLocacao(), new Date()), is(true));
    error.checkThat(isMesmaData(locacao.getDataRetorno(), obterDataComDiferencaDias(1)), is(true));
}

Primeiro nós devemos criar o cenário do teste, iniciando as entidades e dando a elas um valor, chamamos isso de "Given".

Usuario usuario = new Usuario("Usuario 1");
List<Filme> filmes = Arrays.asList(new Filme("Filme 1", 1, 5.0));

Com o cenário criado faremos a ação que desejamos testar, neste caso, alugar um filme, chamamos isso de "When".

Locacao locacao = service.alugarFilme(usuario, filmes);

Por fim, é necessário verificar se tudo está do jeito certo, chamamos isso de "Then".

error.checkThat(locacao.getValor(), is(equalTo(5.0)));
error.checkThat(isMesmaData(locacao.getDataLocacao(), new Date()), is(true));
error.checkThat(isMesmaData(locacao.getDataRetorno(),obterDataComDiferencaDias(1)), is(true));

Conclusão

Com isso é possível criar testes em diversos cenários e ter certeza que sua aplicação não ira quebrar caso haja algum tipo de alteração no código.

Caso esteja interessado, o código está no GitHub