JUnit4 e mokito com Vraptor 4

Se você está tentando implementar teste unitário com Junit4 e Vraptor4 (Maven)...

Você está no lugar certo!

Para não perder muito tempo e para que você possa enterder todo o processo sem dúvidas, vamos usar o projeto que criei do zero nesse outro post 

OBS: Se não você segir o passo a passo e não funcionar, não se preocupe. Disponibilizei o projeto para download no final do post.

Primeiramente vamos adicionar as dependencias do Junit e Mokito no pom.xml

   <!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->
   <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-all</artifactId>
       <version>1.9.5</version>
       <scope>test</scope>
   </dependency>
   <!-- https://mvnrepository.com/artifact/junit/junit -->
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.11</version>
       <scope>test</scope>
   </dependency>

Para facilitar o Mock vamos usar a injeção de dependência no construtor na classe ProductController:

   public class ProductController
   {
   
      private ProductDao productDao;
      private CategoryDao categoryDao;
      private Validator validator;
      private MockSerializationResult result;
      
      
      protected ProductController(){
          this(null,null,null,null);
      }
      
      @Inject
      public ProductController(MockSerializationResult result, Validator validator,ProductDao productDao,CategoryDao categoryDao){
          this.categoryDao = categoryDao;
          this.validator = validator;
          this.productDao = productDao;
          this.result = result;
      }
   

No método save dessa mesma classe vamos adicionar um bloco try/catch para que no teste possamos identificar se deu erro ou sucesso:

      @Post("")
      @Transactional
      public void save(@Valid Product product)
      {
           try {
                 validator.onErrorForwardTo(ProductController.class).formAdd(product);
                 productDao.save(product);
                 result.redirectTo(ProductController.class).list(0);
                 result.include("success", "Incluído com sucesso.");
           } catch (Exception e) {
                 result.include("error", e.getMessage());
           }
      }

Agora vamos criar nossa classe de teste em src/test/java 

Vamos criar um pacote chamado br.com.davifelipe.controllres e dentro desse pacote criar a classe de teste:

   package br.com.davifelipe.controllers;
   
   import static org.junit.Assert.assertTrue;
   
   import java.math.BigDecimal;
   
   import org.junit.Before;
   import org.junit.Test;
   import org.mockito.Mock;
   import org.mockito.MockitoAnnotations;
   import org.mockito.Spy;
   
   import br.com.caelum.vraptor.util.test.MockSerializationResult;
   import br.com.caelum.vraptor.util.test.MockValidator;
   import br.com.caelum.vraptor.validator.Validator;
   import br.com.davifelipe.daos.CategoryDao;
   import br.com.davifelipe.daos.ProductDao;
   import br.com.davifelipe.models.Category;
   import br.com.davifelipe.models.Product;
   
   public class ProductControllerTest {
       private @Mock Product produto;
       private @Spy Validator validator = new MockValidator();
       private @Spy MockSerializationResult result = new MockSerializationResult();
       private ProductController controller;
       private @Mock ProductDao productDao;
       private @Mock CategoryDao categoryDao;
       @Before
       public void setUp() throws Exception {
           MockitoAnnotations.initMocks(this);
           controller = new ProductController(result, validator,productDao,categoryDao);
       }
       @Test()
       public void salvar() throws Exception {
           
           Product produto = new Product();
           produto.setName("Produto de teste");
           Category category = new Category();
           category.setName("Test");
           category.setDescription("Teste Description");
           produto.setDescription("TEsted descript");
           produto.setPrice(new BigDecimal("15.0"));
           produto.setCategory(category);
           controller.save(produto);
           
           assertTrue("Deve exibir uma mensagem de sucesso", result.included().containsKey("success"));
           
       }
   }

Note que na linha em que tem "assertTrue" é verificado se foi incluída uma mensagem com a key "success" dentro no do método save da classe ProductController. 

Feito isso agora basta rodar o teste clicando com botão direto na pasta de teste e clicando em Run As> JUnit Test

Imagem

Se tudo der certo, aparece o reultado do teste como mostra a figura abaixo:

Imagem

Bem, é isso! Agora basta implementar testes para outros métodos e classes do projeto para aumentar a cubertura de testes e seguir a vida. Clique aqui para baixar o projeto usado nesse post.

Comentários

 

Quem Sou

Graduado em ADS (Análise e desenvolvimento de sistemas).

Não sou "devoto" de nenhuma linguagem de programação. Procuro aproveitar o melhor de cada uma de acordo com a necessidade do projeto. Prezo por uma arquitetura bem feita, código limpo, puro e simples! 

anuncio atendente