Teste unitário e Qualidade de Software

Testes de Unidade ou teste unitário é a fase de testes onde cada unidade do sistema é testada individualmente. O objetivo é isolar cada parte do sistema para garantir que elas estejam funcionando conforme especificado.

É preciso planejar bem os testes unitários.

Dessa forma, o desenvolvedor que fará a avaliação deve sempre pensar em quais requisitos aquela funcionalidade a ser testada tem que corresponder, qual deve ser entrada e saída de informações e, também, como funciona o processamento do fluxo daqueles dados.

Unit, é o nome genérico para qualquer estrutura de testes automáticos unitários. Consiste na verificação da menor unidade do projeto de software.

Este tipo de teste é da responsabilidade do próprio programador durante a implementação, isto é, após codificar uma classe por exemplo, seria executado o teste de unidade.

Porém, é de grande importância que um QA esteja comprometido em criar conjuntos de testes unitários que vão contribuir para um melhor desempenho do produto. Pois, se não houver robustez em suas conclusões, toda a técnica falhará.

Através da utilização deste tipo de teste ao longo da implementação é possível reduzir a quantidade de bugs na aplicação final. Os testes do Unit funcionam através de comparação de resultados das funções a serem testadas com valores esperados.

Atualmente existem plataformas específicas de teste para várias linguagens, algumas incluem uma interface gráfica onde se pode ver os testes e a sua conclusão, outros mostram apenas se a conclusão foi correta ou se houveram erros.

Separei algumas ferramentas de exemplo, mas existem muitas outras.

C#

NUnit, Com ele é possível criar casos de teste unitários no Visual Studio e executá-los, obtendo o resultado em um aplicativo gráfico que permite a visualização simplificada do sucesso ou fracasso dos testes executados.

PHP

PHPUnit, com ele é possível criar testes unitários no PHP.

Javascript

• Mocha, bastante conhecido, altamente plugável e com várias features excelentes.
• Jasmine, trabalha com BDD, ou seja, teste orientado a comportamento, bastante utilizado também.
• Jest, criado pelo Facebook para realizar testes no React, trabalha em cima de Mocks por default.
• Protractor, outro para testes E2E, mais focado para o AngularJS.
• QUnit , framework de teste de unidade de JavaScript usado pelo jQuery.

Ruby

• Test::Unit , vem por padrão na linguagem, sendo amplamente utilizada.
• RSpec , framework para testes BDD em Ruby, tem uma ótima documentação.
• Minitest, é uma suite completa de testes, para TDD, BDD, mocks e benchmarking.

Python

• Unit testing framework, talvez a mais comum e conhecida do Python, até por já vir incluída com a linguagem. Bastante poderosa e simples de se utilizar.
• Pytest, outra bastante utilizada no universo Python, possui várias integrações e ótima sintaxe.
• Locust, ferramenta para teste de carga.

Swift

XCTest, framework de teste utilizado pelo Xcode.

Object-C

OCUnit, com ele é possível criar testes unitários no Object-C

Como exemplo vou mostrar o uso do JUnit em app Android

JUnit é um framework que facilita o desenvolvimento e execução de testes unitários em código Java.

Ele Fornece uma completa API para construir os testes e aplicações gráficas em modo console para executar os testes criados.

O JUnit trabalha basicamente com anotações (Annotations). Essas anotações indicam se um método é de teste ou não, se um método deve ser executado antes da classe e/ou depois da classe, indicam também se o teste deve ou não ser ignorado e se a classe em questão é uma suíte de teste, ou seja, se a partir desta classe é disparada a execução das demais classes de teste, entre outras anotações menos utilizadas.

Exemplo de anotações

Para determinar se um método é de teste utilizamos logo acima da classe de teste a anotação: * @Test

Para ignorar um método de teste utilizamos a anotação: @Ignore

Para determinar que um método vai ser executado antes dos demais métodos da classe de teste utilizamos a anotação: @BeforeClass.

Para determinar que um método vai ser executado depois dos demais métodos da classe de teste utilizamos a anotação: @AfterClass.

Para determinar que um método vai ser executado antes de cada caso de teste utilizamos a anotação: @Before.

Exemplo prático do uso de JUnit em app Android

PertApp, é um simples gerenciador de atividades em projetos, o qual realiza o cálculo da técnica PERT.

A técnica PERT tem por objetivo descobrir a duração de uma tarefa baseando-se em três estimativas possíveis para uma determinada atividade: estimativa Otimista (O), Pessimista (P), e mais Provável (MP). Com isso ele gera uma estimativa de dias ou horas de uma atividade com base nestas informações.

Possui a seguinte fórmula

Com apenas alguns cliques, é possível configurar um teste JUnit que é executado na JVM local. Também é possível ampliar seus recursos de teste integrando estruturas de teste, como o Mockito, para testar as chamadas da API do Android em seus testes de unidades locais.

Segue o passo a passo de configuração e utilização

1. Abrir o arquivo Java que contém o código que deseja testar.
2. Selecionar a classe ou método e pressione Ctrl+Shift+T.

3. No menu exibido, clicar em Create New Test.

4. Na caixa de diálogo Create Test, editar os campos e selecionar os métodos a serem gerados e depois clicar em OK.

5. Na caixa de diálogo Choose Destination Directory, clicar no conjunto de origem correspondente ao tipo de teste que você quer criar: test para um teste de unidade local. Depois clicar em OK.

Além disso, deve-se especificar as dependências das bibliotecas de teste no arquivo build.gradle do módulo do aplicativo.

Executando um teste

Para executar o teste é importante seguir os passos:

1. Verificar se o projeto está sincronizado com o Gradle clicando em Sync Project na barra de ferramentas.
2. Na janela Project, clicar com o botão direito na classe de teste e depois em Run.

Para executar os testes, clicar com o botão direito no projeto e selecionar as opções Run As | Android JUnit Test.

No cenário a seguir, consideramos que o teste passou com sucesso, uma vez que realizou o calculo correto com as entradas Otimista = 6, Mais provável = 9, e Pessimista = 20. Sendo assim, seguindo a formula, o resultado correto deve ser 10.

Quando você executa um teste JUnit, os resultados aparecem na janela Executar . Uma barra verde significa que todos os testes foram bem sucedidos e uma barra vermelha significa que pelo menos um teste falhou.

Na próxima imagem, forcei um erro, alterando o valor da estimativa pessimista para 0. Mostrando desta forma um erro de calculo do valor esperado.

Verificando a cobertura de teste

A ferramenta de cobertura de teste está disponível para testes de unidades locais para rastrear a porcentagem e as áreas do código do seu aplicativo que os testes da unidade cobrem.

Esta ferramenta tem por objetivo determinar se você testou adequadamente os elementos, as classes, os métodos e as linhas de código que compõem seu aplicativo.

Há várias maneiras de executar um teste de unidade e são descritos na página IntelliJ Running with Coverage .

O procedimento a seguir mostra como executar um teste de unidade inline a partir do editor:

1. Clicar duas vezes no teste de unidade que deseja executar.
2. No editor, colocar o cursor na linha que deseja executar com cobertura.
3. Clicar com o botão direito do mouse na linha onde você colocou o cursor.
4. No menu de contexto, deve-se Executar nome de teste com cobertura .
5. A janela de ferramenta de cobertura aparece.

Conclusão

Uma boa parte do desenvolvimento e teste do software é pensada na interface, mas o problema é que esses testes em determinados momentos são lentos.

A qualidade de um software não pode ser avaliada em um produto já feito. Então, é aconselhável adotar técnicas que vão melhorar a produção já em seu desenvolvimento, e com os testes unitários, isso é possível.

É importante que um QA saiba quando definir que um determinado teste seja realizado a nível unitário e não de interface, e desta forma ter respostas mais eficientes e rápidas.